Merge branch 'master' into bugfix/unstable-behavior-in-the-predict-logic-test

Author: ngtduc693

Algorithms.Tests/MachineLearning/LogisticRegressionTests.cs

@@ -0,0 +1,65 @@
+using NUnit.Framework;
+using Algorithms.MachineLearning;
+using System;
+
+namespace Algorithms.Tests.MachineLearning;
+
+[TestFixture]
+public class LogisticRegressionTests
+{
+    [Test]
+    public void Fit_ThrowsOnEmptyInput()
+    {
+        var model = new LogisticRegression();
+        Assert.Throws<ArgumentException>(() => model.Fit(Array.Empty<double[]>(), Array.Empty<int>()));
+    }
+
+    [Test]
+    public void Fit_ThrowsOnMismatchedLabels()
+    {
+        var model = new LogisticRegression();
+        double[][] X = { new double[] { 1, 2 } };
+        int[] y = { 1, 0 };
+        Assert.Throws<ArgumentException>(() => model.Fit(X, y));
+    }
+
+    [Test]
+    public void FitAndPredict_WorksOnSimpleData()
+    {
+        // Simple AND logic
+        double[][] X =
+        {
+            new[] { 0.0, 0.0 },
+            new[] { 0.0, 1.0 },
+            new[] { 1.0, 0.0 },
+            new[] { 1.0, 1.0 }
+        };
+        int[] y = { 0, 0, 0, 1 };
+        var model = new LogisticRegression();
+        model.Fit(X, y, epochs: 2000, learningRate: 0.1);
+        Assert.That(model.Predict(new double[] { 0, 0 }), Is.EqualTo(0));
+        Assert.That(model.Predict(new double[] { 0, 1 }), Is.EqualTo(0));
+        Assert.That(model.Predict(new double[] { 1, 0 }), Is.EqualTo(0));
+        Assert.That(model.Predict(new double[] { 1, 1 }), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void PredictProbability_ThrowsOnFeatureMismatch()
+    {
+        var model = new LogisticRegression();
+        double[][] X = { new double[] { 1, 2 } };
+        int[] y = { 1 };
+        model.Fit(X, y);
+        Assert.Throws<ArgumentException>(() => model.PredictProbability(new double[] { 1 }));
+    }
+
+    [Test]
+    public void FeatureCount_ReturnsCorrectValue()
+    {
+        var model = new LogisticRegression();
+        double[][] X = { new double[] { 1, 2, 3 } };
+        int[] y = { 1 };
+        model.Fit(X, y);
+        Assert.That(model.FeatureCount, Is.EqualTo(3));
+    }
+}

Algorithms.Tests/Problems/JobScheduling/IntervalSchedulingSolverTests.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using Algorithms.Problems.JobScheduling;
+
+namespace Algorithms.Tests.Problems.JobScheduling;
+
+public class IntervalSchedulingSolverTests
+{
+    [Test]
+    public void Schedule_ReturnsEmpty_WhenNoJobs()
+    {
+        var result = IntervalSchedulingSolver.Schedule(new List<Job>());
+        Assert.That(result, Is.Empty);
+    }
+
+    [Test]
+    public void Schedule_ReturnsSingleJob_WhenOnlyOneJob()
+    {
+        var jobs = new List<Job> { new Job(1, 3) };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        Assert.That(result, Has.Count.EqualTo(1));
+        Assert.That(result[0], Is.EqualTo(jobs[0]));
+    }
+
+    [Test]
+    public void Schedule_ThrowsArgumentNullException_WhenJobsIsNull()
+    {
+        Assert.Throws<ArgumentNullException>(() => IntervalSchedulingSolver.Schedule(jobs: null!));
+    }
+
+    [Test]
+    public void Schedule_SelectsJobsWithEqualEndTime()
+    {
+        var jobs = new List<Job>
+        {
+            new Job(1, 4),
+            new Job(2, 4),
+            new Job(4, 6)
+        };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        Assert.That(result, Has.Count.EqualTo(2));
+        Assert.That(result, Does.Contain(new Job(1, 4)));
+        Assert.That(result, Does.Contain(new Job(4, 6)));
+    }
+
+    [Test]
+    public void Schedule_SelectsJobStartingAtLastEnd()
+    {
+        var jobs = new List<Job>
+        {
+            new Job(1, 3),
+            new Job(3, 5),
+            new Job(5, 7)
+        };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        Assert.That(result, Has.Count.EqualTo(3));
+        Assert.That(result[0], Is.EqualTo(jobs[0]));
+        Assert.That(result[1], Is.EqualTo(jobs[1]));
+        Assert.That(result[2], Is.EqualTo(jobs[2]));
+    }
+
+    [Test]
+    public void Schedule_HandlesJobsWithNegativeTimes()
+    {
+        var jobs = new List<Job>
+        {
+            new Job(-5, -3),
+            new Job(-2, 1),
+            new Job(0, 2)
+        };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        Assert.That(result, Has.Count.EqualTo(2));
+        Assert.That(result, Does.Contain(new Job(-5, -3)));
+        Assert.That(result, Does.Contain(new Job(-2, 1)));
+    }
+
+    [Test]
+    public void Schedule_SelectsNonOverlappingJobs()
+    {
+        var jobs = new List<Job>
+        {
+            new Job(1, 4),
+            new Job(3, 5),
+            new Job(0, 6),
+            new Job(5, 7),
+            new Job(8, 9),
+            new Job(5, 9)
+        };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        // Expected: (1,4), (5,7), (8,9)
+        Assert.That(result, Has.Count.EqualTo(3));
+        Assert.That(result, Does.Contain(new Job(1, 4)));
+        Assert.That(result, Does.Contain(new Job(5, 7)));
+        Assert.That(result, Does.Contain(new Job(8, 9)));
+    }
+
+    [Test]
+    public void Schedule_HandlesFullyOverlappingJobs()
+    {
+        var jobs = new List<Job>
+        {
+            new Job(1, 5),
+            new Job(2, 6),
+            new Job(3, 7)
+        };
+        var result = IntervalSchedulingSolver.Schedule(jobs);
+        // Only one job can be selected
+        Assert.That(result, Has.Count.EqualTo(1));
+    }
+}

Algorithms.Tests/Problems/TravelingSalesman/TravelingSalesmanSolverTests.cs

@@ -0,0 +1,121 @@
+using Algorithms.Problems.TravelingSalesman;
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Problems.TravelingSalesman;
+
+/// <summary>
+/// Unit tests for TravelingSalesmanSolver. Covers brute-force and nearest neighbor methods, including edge cases and invalid input.
+/// </summary>
+[TestFixture]
+public class TravelingSalesmanSolverTests
+{
+    /// <summary>
+    /// Tests brute-force TSP solver on a 4-city symmetric distance matrix with known optimal route.
+    /// </summary>
+    [Test]
+    public void SolveBruteForce_KnownOptimalRoute_ReturnsCorrectResult()
+    {
+        // Distance matrix for 4 cities (symmetric, triangle inequality holds)
+        double[,] matrix =
+        {
+            { 0, 10, 15, 20 },
+            { 10, 0, 35, 25 },
+            { 15, 35, 0, 30 },
+            { 20, 25, 30, 0 }
+        };
+        var (route, distance) = TravelingSalesmanSolver.SolveBruteForce(matrix);
+        // Optimal route: 0 -> 1 -> 3 -> 2 -> 0, total distance = 80
+        Assert.That(distance, Is.EqualTo(80));
+        Assert.That(route, Is.EquivalentTo(new[] { 0, 1, 3, 2, 0 }));
+    }
+
+    /// <summary>
+    /// Tests nearest neighbor heuristic on the same matrix. May not be optimal.
+    /// </summary>
+    [Test]
+    public void SolveNearestNeighbor_Heuristic_ReturnsFeasibleRoute()
+    {
+        double[,] matrix =
+        {
+            { 0, 10, 15, 20 },
+            { 10, 0, 35, 25 },
+            { 15, 35, 0, 30 },
+            { 20, 25, 30, 0 }
+        };
+        var (route, distance) = TravelingSalesmanSolver.SolveNearestNeighbor(matrix, 0);
+        // Route: 0 -> 1 -> 3 -> 2 -> 0, total distance = 80
+        Assert.That(route.Length, Is.EqualTo(5));
+        Assert.That(route.First(), Is.EqualTo(0));
+        Assert.That(route.Last(), Is.EqualTo(0));
+        Assert.That(distance, Is.GreaterThanOrEqualTo(80)); // Heuristic may be optimal or suboptimal
+    }
+
+    /// <summary>
+    /// Tests nearest neighbor with invalid start index.
+    /// </summary>
+    [Test]
+    public void SolveNearestNeighbor_InvalidStart_ThrowsException()
+    {
+        double[,] matrix =
+        {
+            { 0, 1 },
+            { 1, 0 }
+        };
+        Assert.Throws<ArgumentOutOfRangeException>(() => TravelingSalesmanSolver.SolveNearestNeighbor(matrix, -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => TravelingSalesmanSolver.SolveNearestNeighbor(matrix, 2));
+    }
+    
+    /// <summary>
+    /// Tests nearest neighbor when no unvisited cities remain (should throw InvalidOperationException).
+    /// </summary>
+    [Test]
+    public void SolveNearestNeighbor_NoUnvisitedCities_ThrowsException()
+    {
+        // Construct a matrix where one city cannot be reached (simulate unreachable city)
+        double[,] matrix =
+        {
+            { 0, double.MaxValue, 1 },
+            { double.MaxValue, 0, double.MaxValue },
+            { 1, double.MaxValue, 0 }
+        };
+        // Start at city 0, city 1 is unreachable from both 0 and 2
+        Assert.Throws<InvalidOperationException>(() => TravelingSalesmanSolver.SolveNearestNeighbor(matrix, 0));
+    }
+
+    /// <summary>
+    /// Tests brute-force and nearest neighbor with non-square matrix.
+    /// </summary>
+    [Test]
+    public void NonSquareMatrix_ThrowsException()
+    {
+        double[,] matrix = new double[2, 3];
+        Assert.Throws<ArgumentException>(() => TravelingSalesmanSolver.SolveBruteForce(matrix));
+        Assert.Throws<ArgumentException>(() => TravelingSalesmanSolver.SolveNearestNeighbor(matrix, 0));
+    }
+
+    /// <summary>
+    /// Tests brute-force with less than two cities (invalid case).
+    /// </summary>
+    [Test]
+    public void SolveBruteForce_TooFewCities_ThrowsException()
+    {
+        double[,] matrix = { { 0 } };
+        Assert.Throws<ArgumentException>(() => TravelingSalesmanSolver.SolveBruteForce(matrix));
+    }
+
+    /// <summary>
+    /// Tests nearest neighbor with only two cities (trivial case).
+    /// </summary>
+    [Test]
+    public void SolveNearestNeighbor_TwoCities_ReturnsCorrectRoute()
+    {
+        double[,] matrix =
+        {
+            { 0, 5 },
+            { 5, 0 }
+        };
+        var (route, distance) = TravelingSalesmanSolver.SolveNearestNeighbor(matrix, 0);
+        Assert.That(route, Is.EquivalentTo(new[] { 0, 1, 0 }));
+        Assert.That(distance, Is.EqualTo(10));
+    }
+}

Algorithms.Tests/Sequences/DivisorsCountSequenceTests.cs

@@ -8,17 +8,17 @@ public class DivisorsCountSequenceTests
     public void First10ElementsCorrect()
     {
         // These values are taken from https://oeis.org/A000005 for comparison.
-        var oeisSource = new BigInteger[]
-                         {
-                             1,  2, 2, 3,  2,  4,  2,  4,  3, 4, 2,  6, 2,
-                             4,  4, 5, 2,  6,  2,  6,  4,  4, 2, 8,  3, 4,
-                             4,  6, 2, 8,  2,  6,  4,  4,  4, 9, 2,  4, 4,
-                             8,  2, 8, 2,  6,  6,  4,  2, 10, 3, 6,  4, 6,
-                             2,  8, 4, 8,  4,  4,  2, 12,  2, 4, 6,  7, 4,
-                             8,  2, 6, 4,  8,  2, 12,  2,  4, 6, 6,  4, 8,
-                             2, 10, 5, 4,  2, 12,  4,  4,  4, 8, 2, 12, 4,
-                             6,  4, 4, 4, 12,  2,  6,  6,  9, 2, 8,  2, 8,
-                         };
+        BigInteger[] oeisSource =
+        [
+            1,  2, 2, 3,  2,  4,  2,  4,  3, 4, 2,  6, 2,
+            4,  4, 5, 2,  6,  2,  6,  4,  4, 2, 8,  3, 4,
+            4,  6, 2, 8,  2,  6,  4,  4,  4, 9, 2,  4, 4,
+            8,  2, 8, 2,  6,  6,  4,  2, 10, 3, 6,  4, 6,
+            2,  8, 4, 8,  4,  4,  2, 12,  2, 4, 6,  7, 4,
+            8,  2, 6, 4,  8,  2, 12,  2,  4, 6, 6,  4, 8,
+            2, 10, 5, 4,  2, 12,  4,  4,  4, 8, 2, 12, 4,
+            6,  4, 4, 4, 12,  2,  6,  6,  9, 2, 8,  2, 8,
+        ];
 
         var sequence = new DivisorsCountSequence().Sequence.Take(oeisSource.Length);
         sequence.SequenceEqual(oeisSource).Should().BeTrue();

Algorithms.Tests/Sequences/EulerTotientSequenceTests.cs

@@ -11,8 +11,8 @@ public void FirstElementsCorrect()
         //  Initial test of 69 number from table at https://oeis.org/A000010/list and passed test.
         //  Extended out to 500 values from https://primefan.tripod.com/Phi500.html and passed initial 69
         // along with remaining values.
-        var check = new BigInteger[]
-                    {
+        BigInteger[] check =
+        [
                         1,     1,   2,   2,   4,   2,   6,   4,   6,   4,  10,   4,  12,   6,   8,   8,  16,   6,  18,   8,
                         12,   10,  22,   8,  20,  12,  18,  12,  28,   8,  30,  16,  20,  16,  24,  12,  36,  18,  24,  16,
                         40,   12,  42,  20,  24,  22,  46,  16,  42,  20,  32,  24,  52,  18,  40,  24,  36,  28,  58,  16,
@@ -38,7 +38,7 @@ public void FirstElementsCorrect()
                         252, 192, 442, 144, 352, 222, 296, 192, 448, 120, 400, 224, 300, 226, 288, 144, 456, 228, 288, 176,
                         460, 120, 462, 224, 240, 232, 466, 144, 396, 184, 312, 232, 420, 156, 360, 192, 312, 238, 478, 128,
                         432, 240, 264, 220, 384, 162, 486, 240, 324, 168, 490, 160, 448, 216, 240, 240, 420, 164, 498, 200,
-                    };
+        ];
 
         var sequence = new EulerTotientSequence().Sequence.Take(check.Length);
         sequence.SequenceEqual(check).Should().BeTrue();

Algorithms.Tests/Sequences/FibonacciSequenceTests.cs

@@ -8,7 +8,8 @@ public class FibonacciSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new FibonacciSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 })
+        BigInteger[] expected = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }

Algorithms.Tests/Sequences/KolakoskiSequenceTests.cs

@@ -8,8 +8,8 @@ public class KolakoskiSequenceTests
     public void First100ElementsCorrect()
     {
         // Taken from https://oeis.org/A000002
-        var expected = new BigInteger[]
-        {
+        BigInteger[] expected =
+        [
             1, 2, 2, 1, 1, 2, 1, 2, 2, 1,
             2, 2, 1, 1, 2, 1, 1, 2, 2, 1,
             2, 1, 1, 2, 1, 2, 2, 1, 1, 2,
@@ -20,7 +20,7 @@ public void First100ElementsCorrect()
             1, 2, 1, 2, 2, 1, 2, 1, 1, 2,
             2, 1, 2, 2, 1, 1, 2, 1, 2, 2,
             1, 2, 2, 1, 1, 2, 1, 1, 2, 2,
-        };
+        ];
 
         var sequence = new KolakoskiSequence().Sequence.Take(100);
         var sequence2 = new KolakoskiSequence2().Sequence.Take(100);

Algorithms.Tests/Sequences/NaturalSequenceTests.cs

@@ -8,7 +8,8 @@ public class NaturalSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new NaturalSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })
+        BigInteger[] expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }

Algorithms.Tests/Sequences/NegativeIntegersSequenceTests.cs

@@ -8,7 +8,8 @@ public class NegativeIntegersSequenceTests
     public void First10ElementsCorrect()
     {
         var sequence = new NegativeIntegersSequence().Sequence.Take(10);
-        sequence.SequenceEqual(new BigInteger[] { -1, -2, -3, -4, -5, -6, -7, -8, -9, -10 })
+        BigInteger[] expected = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10];
+        sequence.SequenceEqual(expected)
             .Should().BeTrue();
     }
 }