Add Manhattan distance and tests (#307)

Author: dideldev

Algorithms.Tests/LinearAlgebra/Distances/ManhattanTests.cs

@@ -0,0 +1,40 @@
+using NUnit.Framework;
+using Algorithms.LinearAlgebra.Distances;
+using FluentAssertions;
+using System;
+
+namespace Algorithms.Tests.LinearAlgebra.Distances
+{
+    public class ManhattanTests
+    {
+        /// <summary>
+        /// Test the result given by Manhattan distance function. 
+        /// </summary>
+        /// <param name="point1">Origin point.</param>
+        /// <param name="point2">Target point.</param>
+        /// <param name="expectedDistance">Expected result.</param>
+        [Test]
+        [TestCase(new[] { 1.5 }, new[] { -1.0 }, 2.5)]
+        [TestCase(new[] { 2.0, 3.0 }, new[] { -1.0, 5.0 }, 5)]
+        [TestCase(new[] { 1.0, 2.0, 3.0 }, new[] { 1.0, 2.0, 3.0 }, 0)]
+        [TestCase(new[] { 1.0, 2.0, 3.0, 4.0 }, new[] { 1.75, 2.25, -3.0, 0.5 }, 10.5)]
+        public void DistanceTest(double[] point1, double[] point2, double expectedDistance)
+        {
+            Manhattan.Distance(point1, point2).Should().BeApproximately(expectedDistance, 0.01);
+        }
+
+        /// <summary>
+        /// Test that it throws ArgumentException if two different dimension arrays are given.
+        /// </summary>
+        /// <param name="point1">First point of N dimensions.</param>
+        /// <param name="point2">Second point of M dimensions, M != N.</param>
+        [Test]
+        [TestCase(new[] { 2.0, 3.0 }, new[] { -1.0 })]
+        [TestCase(new[] { 1.0 }, new[] { 1.0, 2.0, 3.0 })]
+        public void DistanceThrowsArgumentExceptionOnDifferentPointDimensions(double[] point1, double[] point2)
+        {
+            Action action = () => Manhattan.Distance(point1, point2);
+            action.Should().Throw<ArgumentException>();
+        }
+    }
+}

Algorithms/LinearAlgebra/Distances/Manhattan.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Algorithms.LinearAlgebra.Distances
+{
+    /// <summary>
+    /// Implementation fo Manhattan distance.
+    /// It is the sum of the lengths of the projections of the line segment between the points onto the coordinate axes.
+    /// In other words, it is the sum of absolute difference between the measures in all dimensions of two points.
+    ///
+    /// Its commonly used in regression analysis.
+    /// </summary>
+    public static class Manhattan
+    {
+        /// <summary>
+        /// Calculate Manhattan distance for two N-Dimensional points.
+        /// </summary>
+        /// <param name="point1">First N-Dimensional point.</param>
+        /// <param name="point2">Second N-Dimensional point.</param>
+        /// <returns>Calculated Manhattan distance.</returns>
+        public static double Distance(double[] point1, double[] point2)
+        {
+            if (point1.Length != point2.Length)
+            {
+                throw new ArgumentException("Both points should have the same dimensionality");
+            }
+
+            // distance = |x1-y1| + |x2-y2| + ... + |xn-yn|
+            return point1.Zip(point2, (x1, x2) => Math.Abs(x1 - x2)).Sum();
+        }
+    }
+}

README.md

@@ -33,6 +33,8 @@ This repository contains algorithms and data structures implemented in C# for ed
     * [Dynamic Programming solver](./Algorithms/Knapsack/DynamicProgrammingKnapsackSolver.cs)
     * [Branch and bound solver](./Algorithms/Knapsack/BranchAndBoundKnapsackSolver.cs)
   * [Linear Algebra](./Algorithms/LinearAlgebra)
+    * [Distances](./Algorithms/LinearAlgebra/Distances)
+      * [Manhattan](./Algorithms/LinearAlgebra/Distances/Manhattan.cs)
     * [Eigenvalue](./Algorithms/LinearAlgebra/Eigenvalue)
       * [Power Iteration](./Algorithms/LinearAlgebra/Eigenvalue/PowerIteration.cs)
   * [Numeric](./Algorithms/Numeric)