floating pr tolerance for line intersection

Author: justcoding121

Advanced.Algorithms/DistributedSystems/CircularQueue.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Advanced.Algorithms.DataStructures.DistributedSystems
 {
@@ -12,10 +13,10 @@ public class CircularQueue<T>
         private T[] queue;
 
         //points to the index of next element to be deleted
-        private int start = 0;
+        private int start;
 
         //points to the index new element should be inserted
-        private int end = 0;
+        private int end;
 
         public int Count { get; private set; }
 
@@ -31,7 +32,7 @@ public CircularQueue(int size)
         /// <param name="data"></param>
         public T Enqueue(T data)
         {
-            T deleted = default(T);
+            var deleted = default(T);
 
             //wrap around removing oldest element
             if (end > queue.Length - 1)
@@ -67,22 +68,11 @@ public T Enqueue(T data)
         /// O(bulk.Length) time complexity
         /// </summary>
         /// <param name="bulk"></param>
-        /// <returns></returns>
+        /// <returns>Deleted items.</returns>
         public IEnumerable<T> Enqueue(T[] bulk)
         {
-            var deletedList = new List<T>();
-
-            foreach (var item in bulk)
-            {
-                var deleted = Enqueue(item);
-
-                if (!deleted.Equals(default(T)))
-                {
-                    deletedList.Add(deleted);
-                }
-            }
-
-            return deletedList;
+            return bulk.Select(item => Enqueue(item))
+                .Where(deleted => !deleted.Equals(default(T))).ToList();
         }
 
         /// <summary>

Advanced.Algorithms/DistributedSystems/ConsistentHash.cs

@@ -9,22 +9,21 @@ namespace Advanced.Algorithms.DistributedSystems
 
     /// <summary>
     /// A consistant hash implementation with MurmurHash
-    /// Adapted from https://github.com/wsq003/consistent-hash/blob/master/ConsistentHash.cs
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public class ConsistentHash<T>
     {
-        SortedDictionary<int, T> circle = new SortedDictionary<int, T>();
-        int[] circleKeys;
-        int replicas;
+        readonly SortedDictionary<int, T> circle = new SortedDictionary<int, T>();
+        private int[] circleKeys;
+        readonly int replicas;
 
         public ConsistentHash()
             : this(new List<T>(), 100) { }
 
         public ConsistentHash(IEnumerable<T> nodes, int replicas)
         {
             this.replicas = replicas;
-            foreach (T node in nodes)
+            foreach (var node in nodes)
             {
                 AddNode(node);
             }
@@ -36,9 +35,9 @@ public ConsistentHash(IEnumerable<T> nodes, int replicas)
         /// <param name="node"></param>
         public void AddNode(T node)
         {
-            for (int i = 0; i < replicas; i++)
+            for (var i = 0; i < replicas; i++)
             {
-                int hash = getHashCode(node.GetHashCode().ToString() + i);
+                var hash = getHashCode(node.GetHashCode().ToString() + i);
                 circle[hash] = node;
             }
 
@@ -52,8 +51,8 @@ public void AddNode(T node)
         /// <returns></returns>
         public T GetNode(string key)
         {
-            int hash = getHashCode(key);
-            int first = Next_ClockWise(circleKeys, hash);
+            var hash = getHashCode(key);
+            var first = nextClockWise(circleKeys, hash);
             return circle[circleKeys[first]];
         }
 
@@ -63,9 +62,9 @@ public T GetNode(string key)
         /// <param name="node"></param>
         public void RemoveNode(T node)
         {
-            for (int i = 0; i < replicas; i++)
+            for (var i = 0; i < replicas; i++)
             {
-                int hash = getHashCode(node.GetHashCode().ToString() + i);
+                var hash = getHashCode(node.GetHashCode().ToString() + i);
                 if (!circle.Remove(hash))
                 {
                     throw new Exception("Cannot remove a node that was never added.");
@@ -82,21 +81,20 @@ public void RemoveNode(T node)
         /// <param name="keys"></param>
         /// <param name="hashCode"></param>
         /// <returns>Returns the index of bucket</returns>
-        int Next_ClockWise(int[] keys, int hashCode)
+        private int nextClockWise(int[] keys, int hashCode)
         {
-            int begin = 0;
-            int end = keys.Length - 1;
+            var begin = 0;
+            var end = keys.Length - 1;
 
             if (keys[end] < hashCode || keys[0] > hashCode)
             {
                 return 0;
             }
 
             //do a binary search
-            int mid = begin;
             while (end - begin > 1)
             {
-                mid = (end + begin) / 2;
+                var mid = (end + begin) / 2;
                 if (keys[mid] >= hashCode)
                 {
                     end = mid;
@@ -118,6 +116,9 @@ private static int getHashCode(string key)
 
     }
 
+    /// <summary>
+    /// Adapted from https://github.com/wsq003/consistent-hash/blob/master/ConsistentHash.cs
+    /// </summary>
     internal class MurmurHash2
     {
         internal static UInt32 Hash(Byte[] data)

Advanced.Algorithms/DistributedSystems/LRUCache.cs

@@ -1,19 +1,18 @@
 using Advanced.Algorithms.DataStructures;
 using System;
-using System.Collections.Generic;
 using System.Linq;
 
 
 namespace Advanced.Algorithms.DistributedSystems
 {
     public class LRUCache<K, V>
     {
-        private int capacity;
+        private readonly int capacity;
 
         private System.Collections.Generic.Dictionary<K, DoublyLinkedListNode<Tuple<K, V>>> lookUp
             = new System.Collections.Generic.Dictionary<K, DoublyLinkedListNode<Tuple<K, V>>>();
 
-        private DoublyLinkedList<Tuple<K, V>> dll = new DoublyLinkedList<Tuple<K, V>>();
+        private readonly DoublyLinkedList<Tuple<K, V>> dll = new DoublyLinkedList<Tuple<K, V>>();
 
         public LRUCache(int capacity)
         {

Advanced.Algorithms/Geometry/ClosestPointPair.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Advanced.Algorithms.Geometry
 {
@@ -35,7 +33,7 @@ public static double Find(List<Point> points, int left, int right)
 
             var strips = new List<Point>();
 
-            for (int i = left; i <= right; i++)
+            for (var i = left; i <= right; i++)
             {
                 if (Math.Abs(points[i].x - midX) < min)
                 {
@@ -46,9 +44,9 @@ public static double Find(List<Point> points, int left, int right)
             //vertical strips within the radius of min
             strips = strips.OrderBy(p => p.y).ToList();
 
-            for (int i = 0; i < strips.Count; i++)
+            for (var i = 0; i < strips.Count; i++)
             {
-                for (int j = i + 1; j < strips.Count && Math.Abs(strips[i].y - strips[j].y) < min; j++)
+                for (var j = i + 1; j < strips.Count && Math.Abs(strips[i].y - strips[j].y) < min; j++)
                 {
                     //check for radius 
                     min = Math.Min(min, getDistance(strips[i], strips[j]));
@@ -60,12 +58,12 @@ public static double Find(List<Point> points, int left, int right)
 
         }
 
-        private static double bruteForce(List<Point> points, int left, int right)
+        private static double bruteForce(IList<Point> points, int left, int right)
         {
             var min = double.MaxValue;
-            for (int i = left; i < right; i++)
+            for (var i = left; i < right; i++)
             {
-                for (int j = left + 1; j <= right; j++)
+                for (var j = left + 1; j <= right; j++)
                 {
                     min = Math.Min(min, getDistance(points[i], points[j]));
                 }

Advanced.Algorithms/Geometry/ConvexHull.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace Advanced.Algorithms.Geometry
 {
@@ -32,7 +28,7 @@ public static List<int[]> Find(List<int[]> points)
                 //pick a random point as next Point
                 var nextPointIndex = (currentPointIndex + 1) % points.Count;
 
-                for (int i = 0; i < points.Count; i++)
+                for (var i = 0; i < points.Count; i++)
                 {
                     if (i == nextPointIndex)
                     {
@@ -77,20 +73,16 @@ private static Orientation getOrientation(int[] p, int[] q, int[] r)
             {
                 return Orientation.ClockWise;
             }
-            else if (result > 0)
-            {
-                return Orientation.AntiClockWise;
-            }
 
-            return Orientation.Colinear;
+            return result > 0 ? Orientation.AntiClockWise : Orientation.Colinear;
         }
 
 
         private static int findLeftMostPoint(List<int[]> points)
         {
             var left = 0;
 
-            for (int i = 1; i < points.Count; i++)
+            for (var i = 1; i < points.Count; i++)
             {
                 if (points[i][0] < points[left][0])
                 {

Advanced.Algorithms/Geometry/LineIntersection.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Advanced.Algorithms.Geometry
 {
@@ -28,8 +24,9 @@ public class LineIntersection
         /// </summary>
         /// <param name="lineA"></param>
         /// <param name="lineB"></param>
-        /// <returns></returns>
-        public static Point FindIntersection(Line lineA, Line lineB)
+        /// <param name="tolerance">precision tolerance.</param>
+        /// <returns>The point of intersection.</returns>
+        public static Point FindIntersection(Line lineA, Line lineB, double tolerance = 0.001)
         {
             double x1 = lineA.x1, y1 = lineA.y1;
             double x2 = lineA.x2, y2 = lineA.y2;
@@ -38,25 +35,25 @@ public static Point FindIntersection(Line lineA, Line lineB)
             double x4 = lineB.x2, y4 = lineB.y2;
 
             //equations of the form x=c (two vertical lines)
-            if (x1 == x2 && x3 == x4 && x1 == x3)
+            if (Math.Abs(x1 - x2) < tolerance && Math.Abs(x3 - x4) < tolerance && Math.Abs(x1 - x3) < tolerance)
             {
                 throw new Exception("Both lines overlap vertically, ambiguous intersection points.");
             }
 
             //equations of the form y=c (two horizontal lines)
-            if (y1 == y2 && y3 == y4 && y1 == y3)
+            if (Math.Abs(y1 - y2) < tolerance && Math.Abs(y3 - y4) < tolerance && Math.Abs(y1 - y3) < tolerance)
             {
                 throw new Exception("Both lines overlap horizontally, ambiguous intersection points.");
             }
 
             //equations of the form x=c (two vertical lines)
-            if (x1 == x2 && x3 == x4)
+            if (Math.Abs(x1 - x2) < tolerance && Math.Abs(x3 - x4) < tolerance)
             {
                 return default(Point);
             }
 
             //equations of the form y=c (two horizontal lines)
-            if (y1 == y2 && y3 == y4)
+            if (Math.Abs(y1 - y2) < tolerance && Math.Abs(y3 - y4) < tolerance)
             {
                 return default(Point);
             }
@@ -72,11 +69,11 @@ public static Point FindIntersection(Line lineA, Line lineB)
             //-m2x + y = c2 --------(4)
 
             double x, y;
-            
+
             //lineA is vertical x1 = x2
             //slope will be infinity
             //so lets derive another solution
-            if (x1 == x2)
+            if (Math.Abs(x1 - x2) < tolerance)
             {
                 //compute slope of line 2 (m2) and c2
                 double m2 = (y4 - y3) / (x4 - x3);
@@ -92,7 +89,7 @@ public static Point FindIntersection(Line lineA, Line lineB)
             //lineB is vertical x3 = x4
             //slope will be infinity
             //so lets derive another solution
-            else if (x3 == x4)
+            else if (Math.Abs(x3 - x4) < tolerance)
             {
                 //compute slope of line 1 (m1) and c2
                 double m1 = (y2 - y1) / (x2 - x1);
@@ -125,8 +122,8 @@ public static Point FindIntersection(Line lineA, Line lineB)
                 //verify by plugging intersection point (x, y)
                 //in orginal equations (1) & (2) to see if they intersect
                 //otherwise x,y values will not be finite and will fail this check
-                if (!(-m1 * x + y == c1
-                    && -m2 * x + y == c2))
+                if (!(Math.Abs(-m1 * x + y - c1) < tolerance
+                    && Math.Abs(-m2 * x + y - c2) < tolerance))
                 {
                     return default(Point);
                 }
@@ -137,7 +134,7 @@ public static Point FindIntersection(Line lineA, Line lineB)
             if (IsInsideLine(lineA, x, y) &&
                 IsInsideLine(lineB, x, y))
             {
-                return new Point() { x = x, y = y };
+                return new Point { x = x, y = y };
             }
 
             //return default null (no intersection)
@@ -154,10 +151,10 @@ public static Point FindIntersection(Line lineA, Line lineB)
         /// <returns></returns>
         private static bool IsInsideLine(Line line, double x, double y)
         {
-            return ((x >= line.x1 && x <= line.x2)
-                        || (x >= line.x2 && x <= line.x1))
-                   && ((y >= line.y1 && y <= line.y2)
-                        || (y >= line.y2 && y <= line.y1));
+            return (x >= line.x1 && x <= line.x2
+                        || x >= line.x2 && x <= line.x1)
+                   && (y >= line.y1 && y <= line.y2
+                        || y >= line.y2 && y <= line.y1);
         }
     }
 }

Advanced.Algorithms/Geometry/PointInsidePolygon.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace Advanced.Algorithms.Geometry
 {

Advanced.Algorithms/Geometry/PointRotation.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Advanced.Algorithms.Geometry
 {
@@ -22,7 +18,7 @@ public static Point Rotate(Point center, Point point, int angle)
             var y = sinTheta * (point.x - center.x) +
                     cosTheta * (point.y - center.y) + center.y;
 
-            return new Point() { x = x, y = y };
+            return new Point { x = x, y = y };
         }
     }
 }