refactored. narrowing preserves size optionally

MaxRev-Dev · MaxRev-Dev · commit 26d3c62ba853 · 2019-10-30T00:49:54.000+02:00
diff --git a/BinaryRelations/Binary/Extremums.cs b/BinaryRelations/Binary/Extremums.cs
@@ -52,11 +52,10 @@ public static IEnumerable<int> GetMaximums(this bool[,] matrix1)
 
                 for (int j = 0; j < length; j++)
                 {
-                    if (!matrix1[i, j])
-                    {
-                        rulePassing = false;
-                        break;
-                    }
+                    if (matrix1[i, j]) 
+                        continue;
+                    rulePassing = false;
+                    break;
                 }
 
                 if (rulePassing)
@@ -81,11 +80,10 @@ public static IEnumerable<int> GetMinimums(this bool[,] matrix1)
 
                 for (int j = 0; j < length; j++)
                 {
-                    if (!matrix1[j, i])
-                    {
-                        rulePassing = false;
-                        break;
-                    }
+                    if (matrix1[j, i])
+                        continue;
+                    rulePassing = false;
+                    break;
                 }
 
                 if (rulePassing)
@@ -110,11 +108,10 @@ public static IEnumerable<int> GetMajorants(this bool[,] matrix1)
 
                 for (int j = 0; j < length; j++)
                 {
-                    if (matrix1[j, i])
-                    {
-                        rulePassing = false;
-                        break;
-                    }
+                    if (!matrix1[j, i]) 
+                        continue;
+                    rulePassing = false;
+                    break;
                 }
 
                 if (rulePassing)
@@ -139,11 +136,10 @@ public static IEnumerable<int> GetMinorants(this bool[,] matrix1)
 
                 for (int j = 0; j < length; j++)
                 {
-                    if (matrix1[i, j])
-                    {
-                        rulePassing = false;
-                        break;
-                    }
+                    if (!matrix1[i, j]) 
+                        continue;
+                    rulePassing = false;
+                    break;
                 }
 
                 if (rulePassing)
diff --git a/BinaryRelations/Binary/UnaryOperations.cs b/BinaryRelations/Binary/UnaryOperations.cs
@@ -70,7 +70,7 @@ public static partial class BinaryRelations
         }
 
         /// <summary>
-        /// Narrows matrix to region defined by the set of X..Xi..Xn. Indexes are starting from 1 
+        /// Narrows matrix to the region defined by the set of X..Xi..Xn. Indexes are starting from 1 and will be sorted
         /// </summary>
         /// <param name="matrix1">binary matrix</param>
         /// <param name="x">index [1..n]</param> 
@@ -80,7 +80,7 @@ public static partial class BinaryRelations
             if (x == null) throw new ArgumentNullException(nameof(x));
             ThrowIfNull_NotQuad(matrix1);
             var length = matrix1.GetLength(0);
-            var set = x.Select(p => --p).ToList();
+            var set = x.Select(p => --p).OrderBy(a => a).ToList();  
             var result = new bool[x.Length, x.Length];
 
             for (int i = 0; i < length; i++)
@@ -92,7 +92,33 @@ public static partial class BinaryRelations
                 }
             }
 
-            return result; 
+            return result;
+        }
+
+        /// <summary>
+        /// Narrows matrix  to the region defined by the set of X..Xi..Xn, but preserves it's original size. Indexes are starting from 1 and will be sorted
+        /// </summary>
+        /// <param name="matrix1">binary matrix</param>
+        /// <param name="x">index [1..n]</param> 
+        /// <returns>binary matrix</returns>
+        public static bool[,] NarrowingPreserveSize(this bool[,] matrix1, params int[] x)
+        {
+            if (x == null) throw new ArgumentNullException(nameof(x));
+            ThrowIfNull_NotQuad(matrix1);
+            var length = matrix1.GetLength(0);
+            var result = (bool[,])matrix1.Clone();  
+            x = x.Select(p => --p).OrderBy(a => a).ToArray();
+
+            for (int i = 0; i < length; i++)
+            {
+                for (int j = 0; j < length; j++)
+                {
+                    if (!x.Contains(i) || !x.Contains(j))
+                        result[i, j] = false;
+                }
+            }
+
+            return result;
         }
 
         #endregion
diff --git a/BinaryRelations/BinaryRelations.csproj b/BinaryRelations/BinaryRelations.csproj
@@ -3,18 +3,26 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <RootNamespace>MaxRev.Extensions</RootNamespace>
-    <Version>1.3.0</Version>
+    <Version>1.3.2</Version>
     <Authors>MaxRev</Authors>
     <Copyright>MaxRev © 2019</Copyright>
     <Description>Binary relations and matrix extensions library targeting netstandard2.0</Description>
     <PackageProjectUrl>https://github.com/MaxRev-Dev/binary-relations</PackageProjectUrl>
     <RepositoryUrl>https://github.com/MaxRev-Dev/binary-relations</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageTags>binary-relations, maxrev, matrix, matrix-functions, extension-methods, graphs-theory, graphs, matrix-extensions</PackageTags>
-    <PackageReleaseNotes>added cartesian product</PackageReleaseNotes>
+    <PackageReleaseNotes>- added cartesian product
+
+- ordered indexes in narrowing method
+
+- narrowing returns only a specified region (skips empty indexes)
+
+- sorted indexes for narrowing
+    
+- added NarrowingPreserveSize</PackageReleaseNotes>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageId>MaxRev.BinaryRelations</PackageId>
-    <Product>MaxRev.BinaryRelations</Product>
+    <Product>MaxRev.BinaryRelations</Product> 
   </PropertyGroup>
 
 </Project>
diff --git a/BinaryRelationsTests/BinaryRelationsOperationsTests.cs b/BinaryRelationsTests/BinaryRelationsOperationsTests.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Linq;
 using BinaryRelationsTests.Helpers;
 using MaxRev.Extensions.Binary;
 using MaxRev.Extensions.Matrix;
@@ -167,7 +165,8 @@ public void Narrowing()
                 {1, 1, 1},
                 {1, 1, 1},
             }.Cast<int, bool>();
-            Assert.Equal(expected, m1.Narrowing(1, 3, 4));
+            // this set will be ordered by ascending
+            Assert.Equal(expected, m1.Narrowing(4, 1, 3));
 
             expected = new[,]
             {
@@ -189,7 +188,8 @@ public void Narrowing()
                 {1, 1, 1},
                 {0, 1, 0},
             }.Cast<int, bool>();
-            Assert.Equal(expected, m1.Narrowing(1, 3, 4));
+            // this set will be ordered by ascending
+            Assert.Equal(expected, m1.Narrowing(3, 1, 4));
 
             m1 = new[,]
             {
@@ -207,6 +207,52 @@ public void Narrowing()
             Assert.Equal(expected, m1.Narrowing(3, 4));
         }
 
+        [Fact]
+        public void NarrowingPreserveSize()
+        {
+            var m1 = new[,]
+            {
+                {1, 1, 1, 1},
+                {1, 1, 1, 1},
+                {1, 1, 1, 1},
+                {1, 1, 1, 1},
+            }.Cast<int, bool>();
+            var expected = new[,]
+            {
+                {1, 0, 0, 1},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {1, 0, 0, 1},
+            }.Cast<int, bool>();
+            Assert.Equal(expected, m1.NarrowingPreserveSize(1, 4));
+
+            expected = new[,]
+            {
+                {1, 1, 0, 0},
+                {1, 1, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+            }.Cast<int, bool>();
+            Assert.Equal(expected, m1.NarrowingPreserveSize(1, 2));
+
+            expected = new[,]
+            {
+                {1, 0, 1, 1},
+                {0, 0, 0, 0},
+                {1, 0, 1, 1},
+                {1, 0, 1, 1},
+            }.Cast<int, bool>();
+            Assert.Equal(expected, m1.NarrowingPreserveSize(1, 3, 4));
+
+            expected = new[,]
+            {
+                {1, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+                {0, 0, 0, 0},
+            }.Cast<int, bool>();
+            Assert.Equal(expected, m1.NarrowingPreserveSize(1));
+        }
         [Fact]
         public void Reverse()
         {
diff --git a/BinaryRelationsTests/ExtremumsTests.cs b/BinaryRelationsTests/ExtremumsTests.cs
@@ -1,6 +1,6 @@
-using System.Linq;
 using BinaryRelationsTests.Helpers;
 using MaxRev.Extensions.Binary;
+using System.Linq;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/BinaryRelationsTests/MatrixOperationsTests.cs b/BinaryRelationsTests/MatrixOperationsTests.cs
@@ -1,8 +1,7 @@
-using System.Collections.Generic;
-using System.Linq;
 using BinaryRelationsTests.Helpers;
 using MaxRev.Extensions.Binary;
 using MaxRev.Extensions.Matrix;
+using System.Linq;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -109,15 +108,15 @@ public void Permutations()
         public void CartesianProductDistinctPairs()
         {
             var expected = new[] {
-                new[]
+                new []
                 {
                     new[] {1},
                     new[] {2},
                     new[] {3},
                     new[] {4},
                     new[] {5},
                 },
-                new[]
+                new []
                 {
                     new[] {1, 2},
                     new[] {1, 3},
@@ -130,7 +129,7 @@ public void CartesianProductDistinctPairs()
                     new[] {3, 5},
                     new[] {4, 5},
                 },
-                new[]
+                new []
                 {
                     new[] {1, 2, 3},
                     new[] {1, 2, 4},
@@ -143,7 +142,7 @@ public void CartesianProductDistinctPairs()
                     new[] {2, 4, 5},
                     new[] {3, 4, 5},
                 },
-                new[]
+                new []
                 {
                     new[] {1, 2, 3, 4},
                     new[] {1, 2, 3, 5},
