Merge branch 'master' into bug/issue-465-CoverageIssueforHashTableandTimSorterReducingOverallCodeCoverage

Author: siriak

Algorithms.Tests/Numeric/AbsTests.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Numerics;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric;
+
+public static class AbsTests
+{
+    [TestCase(0, 0)]
+    [TestCase(34, 34)]
+    [TestCase(-100000000000.0d, 100000000000.0d)]
+    [TestCase(-3, 3)]
+    [TestCase(-3.1443123d, 3.1443123d)]
+    public static void GetsAbsVal<T>(T inputNum, T expected) where T : INumber<T>
+    {
+        // Act
+        var result = Abs.AbsVal(inputNum);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [TestCase(new[] { -3, -1, 2, -11 }, -11)]
+    [TestCase(new[] { 0, 5, 1, 11 }, 11)]
+    [TestCase(new[] { 3.0, -10.0, -2.0 }, -10.0d)]
+    public static void GetAbsMax<T>(T[] inputNums, T expected) where T : INumber<T>
+    {
+        // Act
+        var result = Abs.AbsMax(inputNums);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public static void AbsMaxThrowsArgumentException()
+    {
+        // Arrange
+        var inputNums = Array.Empty<int>();
+
+        // Assert
+        Assert.Throws<ArgumentException>(() => Abs.AbsMax(inputNums));
+    }
+
+    [TestCase(new[] { -3, -1, 2, -11 }, -1)]
+    [TestCase(new[] { -3, -5, 1, -11 }, 1)]
+    [TestCase(new[] { 0, 5, 1, 11 }, 0)]
+    public static void GetAbsMin<T>(T[] inputNums, T expected) where T : INumber<T>
+    {
+        // Act
+        var result = Abs.AbsMin(inputNums);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public static void AbsMinThrowsArgumentException()
+    {
+        // Arrange
+        var inputNums = Array.Empty<int>();
+
+        // Assert
+        Assert.Throws<ArgumentException>(() => Abs.AbsMin(inputNums));
+    }
+}

Algorithms.Tests/Numeric/SoftMaxTests.cs

@@ -0,0 +1,48 @@
+using System;
+using Algorithms.Numeric;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Numeric;
+
+public static class SoftMaxTests
+{
+    [TestCase(new[] {5.0, 5.0}, new[] {0.5, 0.5})]
+    [TestCase(new[] {1.0, 2.0, 3.0}, new[] {0.09003057317038046, 0.24472847105479767, 0.6652409557748219})]
+    [TestCase(new[] {0.0}, new[] {1.0})]
+    public static void SoftMaxFunction(double[] input, double[] expected)
+    {
+        // Act
+        var result = SoftMax.Compute(input);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(expected).Within(1e-9));
+    }
+
+    [Test]
+    public static void SoftMaxFunctionThrowsArgumentException()
+    {
+        // Arrange
+        var input = Array.Empty<double>();
+
+        // Assert
+        Assert.Throws<ArgumentException>(() => SoftMax.Compute(input));
+    }
+
+    [TestCase(new[] {1.0, 2.0, 3.0, 4.0, 5.0})]
+    [TestCase(new[] {0.0, 0.0, 0.0, 0.0, 0.0})]
+    [TestCase(new[] {5.0})]
+    public static void SoftMaxFunctionSumsToOne(double[] input)
+    {
+        // Act
+        var result = SoftMax.Compute(input);
+
+        var sum = 0.0;
+        foreach (var value in result)
+        {
+            sum += value;
+        }
+
+        // Assert
+        Assert.That(sum, Is.EqualTo(1.0).Within(1e-9));
+    }
+}

Algorithms.Tests/Strings/PatternMatching/WildCardMatcherTests.cs

@@ -0,0 +1,36 @@
+using Algorithms.Strings.PatternMatching;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Strings.PatternMatching;
+
+public static class WildCardMatcherTests
+{
+    [TestCase("aab", "c*a*b", true)]
+    [TestCase("aaa", "aa", false)]
+    [TestCase("aaa", "a.a", true)]
+    [TestCase("aaab", "aa*", false)]
+    [TestCase("aaab", ".*", true)]
+    [TestCase("a", "bbbb", false)]
+    [TestCase("", "bbbb", false)]
+    [TestCase("a", "", false)]
+    [TestCase("", "", true)]
+    public static void MatchPattern(string inputString, string pattern, bool expected)
+    {
+        // Act
+        var result = WildCardMatcher.MatchPattern(inputString, pattern);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public static void MatchPatternThrowsArgumentException()
+    {
+        // Arrange
+        var inputString = "abc";
+        var pattern = "*abc";
+
+        // Assert
+        Assert.Throws<System.ArgumentException>(() => WildCardMatcher.MatchPattern(inputString, pattern));
+    }
+}

Algorithms.Tests/Strings/Similarity/OptimalStringAlignmentTests.cs

@@ -0,0 +1,74 @@
+using Algorithms.Strings.Similarity;
+using FluentAssertions;
+using NUnit.Framework;
+using System;
+
+namespace Algorithms.Tests.Strings.Similarity
+{
+    [TestFixture]
+    public class OptimalStringAlignmentTests
+    {
+        [Test]
+        public void Calculate_IdenticalStrings_ReturnsZero()
+        {
+            var result = OptimalStringAlignment.Calculate("example", "example");
+            result.Should().Be(0.0);
+        }
+
+        [Test]
+        public void Calculate_FirstStringEmpty_ReturnsLengthOfSecondString()
+        {
+            var result = OptimalStringAlignment.Calculate("", "example");
+            result.Should().Be("example".Length);
+        }
+
+        [Test]
+        public void Calculate_SecondStringEmpty_ReturnsLengthOfFirstString()
+        {
+            var result = OptimalStringAlignment.Calculate("example", "");
+            result.Should().Be("example".Length);
+        }
+
+        [Test]
+        public void Calculate_BothStringsEmpty_ReturnsZero()
+        {
+            var result = OptimalStringAlignment.Calculate("", "");
+            result.Should().Be(0.0);
+        }
+
+        [Test]
+        public void Calculate_OneInsertion_ReturnsOne()
+        {
+            var result = OptimalStringAlignment.Calculate("example", "examples");
+            result.Should().Be(1.0);
+        }
+
+        [Test]
+        public void Calculate_OneDeletion_ReturnsOne()
+        {
+            var result = OptimalStringAlignment.Calculate("examples", "example");
+            result.Should().Be(1.0);
+        }
+
+        [Test]
+        public void Calculate_OneSubstitution_ReturnsOne()
+        {
+            var result = OptimalStringAlignment.Calculate("example", "exbmple");
+            result.Should().Be(1.0);
+        }
+
+        [Test]
+        public void Calculate_OneTransposition_ReturnsOne()
+        {
+            var result = OptimalStringAlignment.Calculate("example", "exmaple");
+            result.Should().Be(1.0);
+        }
+
+        [Test]
+        public void Calculate_MultipleOperations_ReturnsCorrectDistance()
+        {
+            var result = OptimalStringAlignment.Calculate("kitten", "sitting");
+            result.Should().Be(3.0);
+        }
+    }
+}

Algorithms/Numeric/Abs.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Numerics;
+
+namespace Algorithms.Numeric;
+
+/// <summary>
+///     Find the absolute value of a number.
+/// </summary>
+public static class Abs
+{
+    /// <summary>
+    ///    Returns the absolute value of a number.
+    /// </summary>
+    /// <typeparam name="T">Type of number.</typeparam>
+    /// <param name="inputNum">Number to find the absolute value of.</param>
+    /// <returns>Absolute value of the number.</returns>
+    public static T AbsVal<T>(T inputNum) where T : INumber<T>
+    {
+        return T.IsNegative(inputNum) ? -inputNum : inputNum;
+    }
+
+    /// <summary>
+    ///   Returns the number with the smallest absolute value on the input array.
+    /// </summary>
+    /// <typeparam name="T">Type of number.</typeparam>
+    /// <param name="inputNums">Array of numbers to find the smallest absolute.</param>
+    /// <returns>Smallest absolute number.</returns>
+    public static T AbsMin<T>(T[] inputNums) where T : INumber<T>
+    {
+        if (inputNums.Length == 0)
+        {
+            throw new ArgumentException("Array is empty.");
+        }
+
+        var min = inputNums[0];
+        for (var index = 1; index < inputNums.Length; index++)
+        {
+            var current = inputNums[index];
+            if (AbsVal(current).CompareTo(AbsVal(min)) < 0)
+            {
+                min = current;
+            }
+        }
+
+        return min;
+    }
+
+    /// <summary>
+    ///  Returns the number with the largest absolute value on the input array.
+    /// </summary>
+    /// <typeparam name="T">Type of number.</typeparam>
+    /// <param name="inputNums">Array of numbers to find the largest absolute.</param>
+    /// <returns>Largest absolute number.</returns>
+    public static T AbsMax<T>(T[] inputNums) where T : INumber<T>
+    {
+        if (inputNums.Length == 0)
+        {
+            throw new ArgumentException("Array is empty.");
+        }
+
+        var max = inputNums[0];
+        for (var index = 1; index < inputNums.Length; index++)
+        {
+            var current = inputNums[index];
+            if (AbsVal(current).CompareTo(AbsVal(max)) > 0)
+            {
+                max = current;
+            }
+        }
+
+        return max;
+    }
+}

Algorithms/Numeric/SoftMax.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace Algorithms.Numeric;
+
+/// <summary>
+///     Implementation of the SoftMax function.
+///     Its a function that takes as input a vector of K real numbers, and normalizes
+///     it into a probability distribution consisting of K probabilities proportional
+///     to the exponentials of the input numbers. After softmax, the elements of the vector always sum up to 1.
+///     https://en.wikipedia.org/wiki/Softmax_function.
+/// </summary>
+public static class SoftMax
+{
+    /// <summary>
+    ///    Compute the SoftMax function.
+    ///    The SoftMax function is defined as:
+    ///    softmax(x_i) = exp(x_i) / sum(exp(x_j)) for j = 1 to n
+    ///    where x_i is the i-th element of the input vector.
+    ///    The elements of the output vector are the probabilities of the input vector, the output sums up to 1.
+    /// </summary>
+    /// <param name="input">The input vector of real numbers.</param>
+    /// <returns>The output vector of real numbers.</returns>
+    public static double[] Compute(double[] input)
+    {
+        if (input.Length == 0)
+        {
+            throw new ArgumentException("Array is empty.");
+        }
+
+        var exponentVector = new double[input.Length];
+        var sum = 0.0;
+        for (var index = 0; index < input.Length; index++)
+        {
+            exponentVector[index] = Math.Exp(input[index]);
+            sum += exponentVector[index];
+        }
+
+        for (var index = 0; index < input.Length; index++)
+        {
+            exponentVector[index] /= sum;
+        }
+
+        return exponentVector;
+    }
+}