code cleanup

Author: muhammadmnorouzi

Laboratory.Test/Generics/ExtensionsTests.cs

@@ -1,5 +1,4 @@
-
-using Labratory.Generics;
+using Labratory.Extensions;
 using Shouldly;
 
 namespace Laboratory.Test.Generics;
@@ -13,7 +12,7 @@ public void Permutate_ShouldReturnAllPossibleCombinations()
         int[] numbers = [1, 2, 3];
         int[][] expectedCombinations = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]];
 
-        foreach (IDictionary<int, int> combination in numbers.Permutate())
+        foreach (IDictionary<int, int> combination in numbers.Permutations())
         {
             expectedCombinations.Any(permutation => permutation.SequenceEqual(combination.Values)).ShouldBe(true);
         }

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.IsDiagonal.cs

@@ -33,7 +33,7 @@ public partial class MatrixTests
     public void TransferToRowReduced_ShouldReturnCorrectlyRowReducedMatrix(int matIndex, int rowReducedMatIndex)
     {
         Matrix mat = new(_matrices[matIndex]);
-        mat.TransferToRowReduced();
+        _ = mat.TransferToRowReduced();
 
         mat.Equals(new Matrix(_matricesRowReduced[rowReducedMatIndex]))
            .ShouldBeTrue();

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.IsEye.cs

@@ -11,23 +11,23 @@ public partial class MatrixTests
     public void IsEye_ShouldReturnTrue_ForEyeMatrix()
     {
         Matrix matrix = new(10, 10);
-        matrix.Eye();
+        _ = matrix.Eye();
         matrix.IsEye(value: 1.0D).ShouldBeTrue();
     }
 
     [Fact]
     public void IsEye_ShouldReturnFalse_ForNoneEyeMatrix()
     {
         Matrix matrix = new(10, 10);
-        matrix.Randomize();
+        _ = matrix.Randomize();
         matrix.IsEye(value: 1.0D).ShouldBeFalse();
     }
 
     [Fact]
     public void IsEye_ShouldReturnFalse_ForNonEyeMatrix2()
     {
         Matrix matrix = new(10, 10);
-        matrix.Eye();
+        _ = matrix.Eye();
         matrix.AtRef(1, 5) = 1;
         matrix.IsEye(value: 1.0D).ShouldBeFalse();
     }
@@ -38,6 +38,6 @@ public void IsEye_ShouldReturnFalse_ForNonEyeMatrix2()
     public void IsEye_ShouldThrowLaboratoryException_ForNonSquareMatrix(int rows, int cols)
     {
         Matrix matrix = new(rows, cols);
-        Assert.Throws<LaboratoryException>(() => matrix.IsEye(value: 1.0D));
+        _ = Assert.Throws<LaboratoryException>(() => matrix.IsEye(value: 1.0D));
     }
 }

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.IsFilled.cs

@@ -14,7 +14,7 @@ public partial class MatrixTests
     public void IsFilled_ShouldReturnTrue_ForFilledMatrix(double value)
     {
         Matrix matrix = new(Random.Shared.Next(1, 10), Random.Shared.Next(1, 10));
-        matrix.Fill(value);
+        _ = matrix.Fill(value);
         matrix.IsFilled(value).ShouldBeTrue();
     }
 
@@ -26,7 +26,7 @@ public void IsFilled_ShouldReturnTrue_ForFilledMatrix(double value)
     public void IsFilled_ShouldReturnFalse_ForNotFilledMatrix(double value)
     {
         Matrix matrix = new(Random.Shared.Next(1, 10), Random.Shared.Next(1, 10));
-        matrix.Randomize();
+        _ = matrix.Randomize();
         matrix.IsFilled(value).ShouldBeFalse();
     }
 }

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.IsInRowReducedForm.cs

@@ -6,7 +6,7 @@ namespace Laboratory.Test.Mathematics.Algebra.Linear.Core.Concretes;
 
 public partial class MatrixTests
 {
-    private readonly List<double[,]> _notRowReducedMatrices = new() {
+    private readonly List<double[,]> _notRowReducedMatrices = [
         new double[4, 5] {
             {1, 1, -2, 4, 7},
             {0, 0, -6, 5, 7},
@@ -24,9 +24,9 @@ public partial class MatrixTests
             {1, -2, 3, 3},
             {0, 0, 1, -3},
             {0, 0, 1, 0}},
-    };
+    ];
 
-    private readonly List<double[,]> _rowReducedMatrices = new() {
+    private readonly List<double[,]> _rowReducedMatrices = [
         new double[4, 5] {
             {1, 1, -2, 4, 7},
             {0, 0, 1, 5, 7},
@@ -44,7 +44,7 @@ public partial class MatrixTests
             {1, -2, 3, 3},
             {0, 1, 1, -3},
             {0, 0, 1, 0}},
-    };
+    ];
 
     [Theory]
     [InlineData(0)]

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.Multiplicate.cs

@@ -90,10 +90,9 @@ public void Multiplicate_ShouldThrowException_ForIncompatibleShapes()
         Matrix right = new Matrix(c, d).Randomize();
 
         // Then
-        Should.Throw<LaboratoryException>(() => left.Multiplicate(right));
+        _ = Should.Throw<LaboratoryException>(() => left.Multiplicate(right));
     }
 
-
     [Fact]
     public void Multiplicate_ShouldWorkCorrectly_ForLargeMatrices()
     {
@@ -106,7 +105,7 @@ public void Multiplicate_ShouldWorkCorrectly_ForLargeMatrices()
         Matrix right = new Matrix(b, c).Randomize();
 
         // Then
-        Should.NotThrow(() => left.Multiplicate(right));
+        _ = Should.NotThrow(() => left.Multiplicate(right));
     }
 
     [Fact]
@@ -117,7 +116,8 @@ public void Multiplicate_ShouldSatisfyAssociativity()
         Matrix mat2 = new Matrix(25, 15).Randomize();
         Matrix mat3 = new Matrix(15, 20).Randomize();
 
-        Matrix expected = mat1.Multiplicate(mat2).Multiplicate(mat3); ;
+        Matrix expected = mat1.Multiplicate(mat2).Multiplicate(mat3);
+        ;
 
         // When
         Matrix result = mat1.Multiplicate(mat2.Multiplicate(mat3));

Laboratory.Test/Mathematics/Algebra/Linear/Core/Concretes/MatrixTests.cs

@@ -29,7 +29,7 @@ public void ShloudCreateNewMatrix_WithPositiveRowsAndColsNumber(int rows, int co
     [InlineData(-1, -11)]
     public void ShloudThrowException_WhenCreatingNewMatrix_WithNonPositiveGivenRowsAndColsNumber(int rows, int cols)
     {
-        Assert.Throws<LaboratoryException>(() => new Matrix(rows, cols));
+        _ = Assert.Throws<LaboratoryException>(() => new Matrix(rows, cols));
     }
 
     [Fact]

Labratory/Exceptions/LaboratoryException.cs

@@ -6,14 +6,13 @@ namespace Labratory.Exceptions;
 
 public sealed class LaboratoryException : Exception
 {
-    public LaboratoryExceptionType ExceptionType => _exceptionType;
-    private readonly LaboratoryExceptionType _exceptionType;
+    public LaboratoryExceptionType ExceptionType { get; }
 
     internal LaboratoryException(
         LaboratoryExceptionType exceptionType,
         string message) : base(message)
     {
-        _exceptionType = exceptionType;
+        ExceptionType = exceptionType;
     }
 
     [DoesNotReturn]
@@ -30,9 +29,9 @@ internal static void ThrowIfNot(bool condition, string message, LaboratoryExcept
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static void ThrowIf(bool condition, string message, LaboratoryExceptionType exceptionType = LaboratoryExceptionType.Internal)
     {
-         if (condition)
+        if (condition)
         {
             throw new LaboratoryException(exceptionType, message);
         }
-    } 
+    }
 }

Labratory/Extensions/Extensions.Generic.cs

@@ -0,0 +1,71 @@
+namespace Labratory.Extensions;
+
+public static partial class Extensions
+{
+    public static IEnumerable<IDictionary<T, T>> Permutations<T>(this IEnumerable<T> values)
+        where T : notnull
+    {
+        var distinctValues = values
+        .Distinct()
+        .ToList();
+
+        foreach (IEnumerable<T> permutation in PermutateInternal(distinctValues, []))
+        {
+            yield return distinctValues
+                .Zip(permutation, (key, value) => (key, value))
+                .ToDictionary(pair => pair.key, pair => pair.value);
+        }
+    }
+
+    private static IEnumerable<IEnumerable<T>> PermutateInternal<T>(List<T> remaining, List<T> current)
+    {
+        if (remaining.Count == 0)
+        {
+            yield return current;
+        }
+        else
+        {
+            for (int i = 0; i < remaining.Count; i++)
+            {
+                List<T> nextCurrent = [.. current, remaining[i]];
+
+                List<T> nextRemaining = [.. remaining];
+                nextRemaining.RemoveAt(i);
+
+                foreach (IEnumerable<T> result in PermutateInternal(nextRemaining, nextCurrent))
+                {
+                    yield return result;
+                }
+            }
+        }
+    }
+
+    public static IEnumerable<IEnumerable<T>> Permutations<T>(IEnumerable<T> list, int length)
+    {
+        return length == 1
+            ? list.Select(t => new T[] { t })
+            : Permutations(list, length - 1)
+            .SelectMany(t => list.Where(e => !t.Contains(e)),
+                        (t1, t2) => t1.Concat(new T[] { t2 }));
+    }
+
+    public static IEnumerable<IEnumerable<T>> Combinations<T>(IEnumerable<T> list, int length)
+    {
+        if (length == 0)
+        {
+            yield return new T[0];
+        }
+
+        var enumerable = list.ToList();
+
+        for (int i = 0; i < enumerable.Count; i++)
+        {
+            IEnumerable<T> head = enumerable.Skip(i).Take(1);
+            IEnumerable<IEnumerable<T>> tailCombinations = Combinations(enumerable.Skip(i + 1), length - 1);
+            foreach (IEnumerable<T> tail in tailCombinations)
+            {
+                yield return head.Concat(tail);
+            }
+        }
+    }
+}