Merge branch 'master' into distance/minkowski

Author: siriak

Algorithms.Tests/Financial/PresentValueTests.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Algorithms.Financial;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Financial;
+
+public static class PresentValueTests
+{
+    [TestCase(0.13,new[] { 10.0, 20.70, -293.0, 297.0 },4.69)]
+    [TestCase(0.07,new[] { -109129.39, 30923.23, 15098.93, 29734.0, 39.0 }, -42739.63)]
+    [TestCase(0.07, new[] { 109129.39, 30923.23, 15098.93, 29734.0, 39.0 }, 175519.15)]
+    [TestCase(0.0, new[] { 109129.39, 30923.23, 15098.93, 29734.0, 39.0 }, 184924.55)]
+
+    public static void Present_Value_General_Tests(double discountRate,double[] cashFlow ,double expected)
+    =>
+        PresentValue.Calculate(discountRate, cashFlow.ToList())
+           .Should()
+           .Be(expected);
+
+
+    [TestCase(-1.0, new[] { 10.0, 20.70, -293.0, 297.0 })]
+    [TestCase(1.0,new double[] {})]
+
+    public static void Present_Value_Exception_Tests(double discountRate, double[] cashFlow)
+    => Assert.Throws<ArgumentException>(() => PresentValue.Calculate(discountRate, cashFlow.ToList()));
+}

Algorithms.Tests/LinearAlgebra/Distances/ChebyshevTests.cs

@@ -0,0 +1,26 @@
+using NUnit.Framework;
+using Algorithms.LinearAlgebra.Distances;
+using FluentAssertions;
+using System;
+
+namespace Algorithms.Tests.LinearAlgebra.Distances;
+
+public class ChebyshevTests
+{
+    [TestCase(new[] { 1.0, 1.0 }, new[] { 2.0, 2.0 }, 1.0)]
+    [TestCase(new[] { 1.0, 1.0, 9.0 }, new[] { 2.0, 2.0, -5.2 }, 14.2)]
+    [TestCase(new[] { 1.0, 2.0, 3.0 }, new[] { 1.0, 2.0, 3.0 }, 0.0)]
+    [TestCase(new[] { 1.0, 2.0, 3.0, 4.0 }, new[] { 1.75, 2.25, -3.0, 0.5 }, 6.0)]
+    public void DistanceTest(double[] point1, double[] point2, double expectedDistance)
+    {
+        Chebyshev.Distance(point1, point2).Should().BeApproximately(expectedDistance, 0.01);
+    }
+
+    [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 = () => Chebyshev.Distance(point1, point2);
+        action.Should().Throw<ArgumentException>();
+    }
+}

Algorithms/Financial/PresentValue.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Algorithms.Financial;
+
+/// <summary>
+/// PresentValue is the value of an expected income stream determined as of the date of valuation.
+/// </summary>
+public static class PresentValue
+{
+    public static double Calculate(double discountRate, List<double> cashFlows)
+    {
+        if (discountRate < 0)
+        {
+            throw new ArgumentException("Discount rate cannot be negative");
+        }
+
+        if (cashFlows.Count == 0)
+        {
+            throw new ArgumentException("Cash flows list cannot be empty");
+        }
+
+        double presentValue = cashFlows.Select((t, i) => t / Math.Pow(1 + discountRate, i)).Sum();
+
+        return Math.Round(presentValue, 2);
+    }
+}

Algorithms/LinearAlgebra/Distances/Chebyshev.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+
+namespace Algorithms.LinearAlgebra.Distances;
+
+/// <summary>
+/// Implementation of Chebyshev distance.
+/// It is the maximum absolute difference between the measures in all dimensions of two points.
+/// In other words, it is the maximum distance one has to travel along any coordinate axis to get from one point to another.
+///
+/// It is commonly used in various fields such as chess, warehouse logistics, and more.
+/// </summary>
+public static class Chebyshev
+{
+    /// <summary>
+    /// Calculate Chebyshev 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 Chebyshev 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 = max(|x1-y1|, |x2-y2|, ..., |xn-yn|)
+        return point1.Zip(point2, (x1, x2) => Math.Abs(x1 - x2)).Max();
+    }
+}

README.md

@@ -58,6 +58,7 @@ find more than one implementation for the same objective but using different alg
     * [IHeuristicKnapsackSolver](./Algorithms/Knapsack/IHeuristicKnapsackSolver.cs)
   * [Linear Algebra](./Algorithms/LinearAlgebra)
     * [Distances](./Algorithms/LinearAlgebra/Distances)
+      * [Chebyshev](./Algorithms/LinearAlgebra/Distances/Chebyshev.cs)
       * [Euclidean](./Algorithms/LinearAlgebra/Distances/Euclidean.cs)
       * [Manhattan](./Algorithms/LinearAlgebra/Distances/Manhattan.cs)
       * [Minkowski](./Algorithms/LinearAlgebra/Distances/Minkowski.cs)