Merge pull request #105 from ColmBhandal/feature/index-map-lambda-init

ColmBhandal · web-flow · commit 601cde512df5 · 2022-01-11T09:35:53.000Z
Feature/index map lambda init
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -30,6 +30,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [BREAKING] Refactored File and Directory Facades & decorators. Updated File creation to throw exception if directory already exists. (#94)
 - [BREAKING] Refactored how the GitHub build works to support a release strategy with pre-releases and semantic versioning. No code changes. (#34)
 - Added class to enumerate over arithmetic sequences of ints (#99)
+- Added new map functions that take indices into account (#103)
+- Added support for lambda/constant array initialisation (#104)
 
 ### Added
 - Support for writing a 1D one-based array to a 2D one-based array (#9)
diff --git a/CsharpExtras/Api/CsharpExtrasApi.cs b/CsharpExtras/Api/CsharpExtrasApi.cs
@@ -60,24 +60,37 @@ public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(TVal[,] zeroBasedBackingA
         }
         public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns)
         {
-            TVal[,] zeroBased = new TVal[rows, columns];
-            return NewOneBasedArray2D(zeroBased);
+            return new OneBasedArray2DImpl<TVal>(rows, columns);
         }
+        public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, Func<int, int, TVal> initialiser)
+        {
+            IOneBasedArray2D<TVal> array = new OneBasedArray2DImpl<TVal>(rows, columns);
+            return array.Map((i, j, _) => initialiser(i, j));
+        }
+        public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, TVal initialValue) =>
+            NewOneBasedArray2D(rows, columns, (i, j) => initialValue);
 
         public IOneBasedArray<TVal> NewOneBasedArray<TVal>(TVal[] zeroBasedBackingArray)
         {
             return new OneBasedArrayImpl<TVal>(zeroBasedBackingArray);
         }
 
-        public ISequentialIntProvider NewSequentialIntProvider(int start, int step)
+        public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size)
         {
-            return new SequentialIntProviderImpl(start, step);
+            return new OneBasedArrayImpl<TVal>(size);
+        }
+        public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, Func<int, TVal> initialiser)
+        {
+            IOneBasedArray<TVal> array = new OneBasedArrayImpl<TVal>(size);
+            return array.Map((i, x) => initialiser(i));
         }
 
-        public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size)
+        public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, TVal initialValue) =>
+            NewOneBasedArray(size, i => initialValue);
+
+        public ISequentialIntProvider NewSequentialIntProvider(int start, int step)
         {
-            TVal[] zeroBased = new TVal[size];
-            return NewOneBasedArray(zeroBased);
+            return new SequentialIntProviderImpl(start, step);
         }
 
         public IFileDecorator NewFileDecorator() => new FileDecoratorImpl();
diff --git a/CsharpExtras/Api/ICsharpExtrasApi.cs b/CsharpExtras/Api/ICsharpExtrasApi.cs
@@ -49,5 +49,9 @@ public interface ICsharpExtrasApi
         ICurryDictionary<TKey, TVal> NewCurryDictionary<TKey, TVal>(int arity);
         ICurryDictionary<TKey, TVal> NewCurryDictionary<TKey, TVal>(PositiveInteger arity);
         ISequentialIntProvider NewSequentialIntProvider(int start, int step);
+        IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, Func<int, int, TVal> initialiser);
+        IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, Func<int, TVal> initialiser);
+        IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, TVal initialValue);
+        IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, TVal initialValue);
     }
 }
diff --git a/CsharpExtras/Enumerable/OneBased/IOneBasedArray.cs b/CsharpExtras/Enumerable/OneBased/IOneBasedArray.cs
@@ -23,6 +23,12 @@ public interface IOneBasedArray<TVal> : IEnumerable<TVal>
         IDictionary<TVal, IList<int>> FindDuplicateIndices();
         IOneBasedArray<TResult> ZipArray<TOther, TResult>(Func<TVal, TOther, TResult> zipper, IOneBasedArray<TOther> other);
         IOneBasedArray<TResult> Map<TResult>(Func<TVal, TResult> mapper);
+        /// <summary>
+        /// Maps elements of this array by applying a function on the existing elements plus their one-based indices.
+        /// </summary>
+        /// <param name="mapper">A function which takes a value & a one-based index and returns a result</param>
+        /// <returns>A new array, the same size as this one, filled with the result of applying the mapper function to the original values & one-based indices.</returns>
+        IOneBasedArray<TResult> Map<TResult>(Func<int, TVal, TResult> mapper);
 
         IDictionary<TVal, IList<int>> InverseMap();
 
diff --git a/CsharpExtras/Enumerable/OneBased/IOneBasedArray2D.cs b/CsharpExtras/Enumerable/OneBased/IOneBasedArray2D.cs
@@ -15,6 +15,12 @@ public interface IOneBasedArray2D<TVal> : IEnumerable<TVal>
 
         int GetLength(int dimZeroBased);
         IOneBasedArray2D<TResult> Map<TResult>(Func<TVal, TResult> mapper);
+        /// <summary>
+        /// Maps elements in this array to a new array, using a mapper function that takes one-based row/column indices as arguments
+        /// </summary>
+        /// <param name="mapper">Takes as arguments a row index, column index and value in the source array and returns the values for the corresponding row/column in the new array</param>
+        /// <returns>A new array containing mapped values</returns>
+        IOneBasedArray2D<TResult> Map<TResult>(Func<int, int, TVal, TResult> mapper);
 
         /// <summary>
         /// Zip two 2D arrays into a single 2D array using a custom zipper function.
diff --git a/CsharpExtras/Enumerable/OneBased/OneBasedArray.cs b/CsharpExtras/Enumerable/OneBased/OneBasedArray.cs
@@ -17,6 +17,10 @@ public OneBasedArrayImpl(TVal[] zeroBasedBackingArray)
             _backingArray = zeroBasedBackingArray;
         }
 
+        public OneBasedArrayImpl(int size) : this(new TVal[size])
+        {
+        }
+
         public TVal this[int oneBasedIndex]
         {
             get
@@ -138,6 +142,13 @@ public IOneBasedArray<TResult> Map<TResult>(Func<TVal, TResult> mapper)
             return new OneBasedArrayImpl<TResult>(zeroBasedMapped);
         }
 
+        public IOneBasedArray<TResult> Map<TResult>(Func<int, TVal, TResult> mapper)
+        {
+            TResult zeroBasedFunc(int i, TVal x) => mapper(i + 1, x);
+            TResult[] zeroBasedMapped = ZeroBasedEquivalent.Map(zeroBasedFunc);
+            return new OneBasedArrayImpl<TResult>(zeroBasedMapped);
+        }
+
         public IDictionary<TVal, IList<int>> FindDuplicateIndices()
         {
             IDictionary<TVal, IList<int>> zeroBasedDuplicates = ZeroBasedEquivalent.FindDuplicateIndices();
diff --git a/CsharpExtras/Enumerable/OneBased/OneBasedArray2D.cs b/CsharpExtras/Enumerable/OneBased/OneBasedArray2D.cs
@@ -26,6 +26,10 @@ public OneBasedArray2DImpl(TVal[,] backingArray)
             ZeroBasedEquivalent = backingArray;
         }
 
+        public OneBasedArray2DImpl(int rows, int columns) : this(new TVal[rows, columns])
+        {
+        }
+
         public TVal this[int oneBasedIndex0, int oneBasedIndex1]
         {
             get
@@ -66,6 +70,13 @@ public IOneBasedArray2D<TResult> Map<TResult>(Func<TVal, TResult> mapper)
             return new OneBasedArray2DImpl<TResult>(mapped);
         }
 
+        public IOneBasedArray2D<TResult> Map<TResult>(Func<int, int, TVal, TResult> mapper)
+        {
+            TResult zeroBasedFunc(int i, int j, TVal x) => mapper(i + 1, j + 1, x);
+            TResult[,] zeroBasedMapped = ZeroBasedEquivalent.Map(zeroBasedFunc);
+            return new OneBasedArray2DImpl<TResult>(zeroBasedMapped);
+        }
+
         public IOneBasedArray2D<TResult> ZipArray<TOther, TResult>(Func<TVal, TOther, TResult> zipper, IOneBasedArray2D<TOther> other)
         {
             TResult[,] zipped = ZeroBasedEquivalent.ZipArray(zipper, other.ZeroBasedEquivalent);
diff --git a/CsharpExtras/Extensions/ArrayExtension.cs b/CsharpExtras/Extensions/ArrayExtension.cs
@@ -194,13 +194,29 @@ public static TResult[] ZipMulti<TOther, TResult>(this TResult[] array, Func<TRe
             return currentZip;
         }
 
+        /// <summary>
+        /// Creates a new array, populated by mapping the values of the old array using a mapper function.
+        /// </summary>
+        /// <param name="mapper">A function which maps an element in the original array to an element in the new array</param>
+        /// <returns>A new array, whose values are the result of applying the mapper function to the associated element in the source array.</returns>
         public static TResult[] Map<TVal, TResult>(this TVal[] array, Func<TVal, TResult> mapper)
+        {
+            TResult func(int i, TVal x) => mapper(x);
+            return array.Map(func);
+        }
+
+        /// <summary>
+        /// Creates a new array, populated by mapping the values/indices of the old array using a mapper function.
+        /// </summary>
+        /// <param name="mapper">A function which maps an element and its index in the original array to an element in the new array.</param>
+        /// <returns>A new array, whose values are the result of applying the mapper function to the associated element in the source array & its index.</returns>
+        public static TResult[] Map<TVal, TResult>(this TVal[] array, Func<int, TVal, TResult> mapper)
         {
             int length = array.Length;
             TResult[] resultArray = new TResult[length];
             for (int i = 0; i < length; i++)
             {
-                resultArray[i] = mapper(array[i]);
+                resultArray[i] = mapper(i, array[i]);
             }
             return resultArray;
         }
diff --git a/CsharpExtras/Extensions/ArrayExtension2D.cs b/CsharpExtras/Extensions/ArrayExtension2D.cs
@@ -171,6 +171,17 @@ public static int Count<TVal>(this TVal[,] array, Func<TVal, bool> checkerFuncti
         }
 
         public static TResult[,] Map<TVal, TResult>(this TVal[,] array, Func<TVal, TResult> mapper)
+        {
+            TResult func(int i, int j, TVal x) => mapper(x);
+            return array.Map(func);
+        }
+
+        /// <summary>
+        /// Creates a new array, populated by mapping the values/indices of the old array using a mapper function.
+        /// </summary>
+        /// <param name="mapper">A function which maps an element and its row/column indices in the original array to an element in the new array</param>
+        /// <returns>A new array, whose values are the result of applying the mapper function to the associated element in the source array & its row/column indices.</returns>
+        public static TResult[,] Map<TVal, TResult>(this TVal[,] array, Func<int, int, TVal, TResult> mapper)
         {
             int length0 = array.GetLength(0);
             int length1 = array.GetLength(1);
@@ -179,7 +190,7 @@ public static int Count<TVal>(this TVal[,] array, Func<TVal, bool> checkerFuncti
             {
                 for (int j = 0; j < length1; j++)
                 {
-                    resultArray[i, j] = mapper(array[i, j]);
+                    resultArray[i, j] = mapper(i, j, array[i, j]);
                 }
             }
             return resultArray;
diff --git a/CsharpExtrasTest/Api/CSharpExtrasApiTest.cs b/CsharpExtrasTest/Api/CSharpExtrasApiTest.cs
@@ -0,0 +1,73 @@
+﻿using CsharpExtras.Api;
+using CsharpExtras.Enumerable.OneBased;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace CsharpExtrasTest.Api
+{
+    [TestFixture, Category("Unit")]
+    public class CSharpExtrasApiTest
+    {
+        ICsharpExtrasApi? _csharpExtrasApi;
+        ICsharpExtrasApi CsharpExtrasApi => _csharpExtrasApi ??= new CsharpExtrasApi();
+
+        [Test]
+        public void GIVEN_IndexPairInitialisationFunction_WHEN_Initialise1DOneBasedArray_THEN_ResultIsAsExpected()
+        {
+            //Assemble
+
+            Func<int, int, (int, int)> func = (i, j) => (i, j);
+
+            //Act
+            IOneBasedArray2D<(int, int)> result = CsharpExtrasApi.NewOneBasedArray2D(2, 2, func);
+
+            //Assert
+            Assert.AreEqual(new (int, int)[,] { { (1, 1), (1, 2) }, { (2,1), (2, 2) } }, result.ZeroBasedEquivalent);
+        }
+
+        [Test]
+        public void GIVEN_Constant_WHEN_Initialise2DOneBasedArray_THEN_ResultantOneBasedArrayIsAsExpected()
+        {
+            //Assemble
+
+            const int C = 7;
+
+            //Act
+            IOneBasedArray2D<int> result = CsharpExtrasApi.NewOneBasedArray2D(2, 2, C);
+
+            //Assert
+            Assert.AreEqual(new int[,] { { C, C }, { C, C } }, result.ZeroBasedEquivalent);
+        }
+
+        [Test]
+        public void GIVEN_IdentityInitialisationFunction_WHEN_Initialise1DOneBasedArray_THEN_ResultIsAsExpected()
+        {
+            //Assemble
+
+            Func<int, int> func = i => i;
+
+            //Act
+            IOneBasedArray<int> result = CsharpExtrasApi.NewOneBasedArray(3, func);
+
+            //Assert
+            Assert.AreEqual(new int[] { 1, 2, 3 }, result.ZeroBasedEquivalent);
+        }
+
+        [Test]
+        public void GIVEN_Constant_WHEN_Initialise1DOneBasedArray_THEN_ResultantOneBasedArrayIsAsExpected()
+        {
+            //Assemble
+
+            const int C = 7;
+
+            //Act
+            IOneBasedArray<int> result = CsharpExtrasApi.NewOneBasedArray(3, C);
+
+            //Assert
+            Assert.AreEqual(new int[] { C, C, C }, result.ZeroBasedEquivalent);
+        }
+    }
+}
diff --git a/CsharpExtrasTest/Enumerable/OneBased/OneBasedArray2DTest.cs b/CsharpExtrasTest/Enumerable/OneBased/OneBasedArray2DTest.cs
@@ -8,8 +8,7 @@
 
 namespace OneBased
 {
-    [TestFixture]
-    [Category("Unit")]
+    [TestFixture, Category("Unit")]
     public class OneBasedArray2DTest
     {
         private const string One = "One";
@@ -19,6 +18,20 @@ public class OneBasedArray2DTest
 
         private readonly ICsharpExtrasApi _api = new CsharpExtrasApi();
 
+        [Test]
+        public void GIVEN_ArrayOfStrings_WHEN_MapByConcatenatingIndices_THEN_ResultIsAsExpected()
+        {
+            //Assemble
+            IOneBasedArray2D<string> array = new OneBasedArray2DImpl<string>(new string[,] { { "OneOne", "OneTwo" }, { "TwoOne", "TwoTwo" } });
+            Func<int, int, string, string> func = (i, j, s) => $"{s}{i},{j}";
+
+            //Act
+            IOneBasedArray2D<string> result = array.Map(func);
+
+            //Assert
+            Assert.AreEqual(new string[,] { { "OneOne1,1", "OneTwo1,2" }, { "TwoOne2,1", "TwoTwo2,2" } }, result);
+        }
+
         [Test]
         public void Given_2DStringArrayWithBlanksOnly_When_LastUsedColumnCalled_Then_ResultIsMinusOne()
         {
diff --git a/CsharpExtrasTest/Enumerable/OneBased/OneBasedArrayTest.cs b/CsharpExtrasTest/Enumerable/OneBased/OneBasedArrayTest.cs
@@ -18,6 +18,20 @@ public class OneBasedArrayTest
         private const string Four = "Four";        
         private readonly ICsharpExtrasApi _api = new CsharpExtrasApi();
 
+        [Test]
+        public void GIVEN_ArrayOfStrings_WHEN_MapByConcatenatingIndices_THEN_ResultIsAsExpected()
+        {
+            //Assemble
+            IOneBasedArray<string> array = new OneBasedArrayImpl<string>(new string[]{ "One", "Two" });
+            Func<int, string, string> func = (i, s) => s + i;
+
+            //Act
+            IOneBasedArray<string> result = array.Map(func);
+
+            //Assert
+            Assert.AreEqual(new string[] { "One1", "Two2" }, result);
+        }
+
         [Test]
         public void Given_OneBasedArray_WhenGetOneBasedFirstIndexOfMatchingElement_Then_OneBasedIndexReturned()
         {
diff --git a/CsharpExtrasTest/Extensions/ArrayExtension2DTest.cs b/CsharpExtrasTest/Extensions/ArrayExtension2DTest.cs
diff --git a/CsharpExtrasTest/Extensions/ArrayExtensionTest.cs b/CsharpExtrasTest/Extensions/ArrayExtensionTest.cs

Original file line number	Diff line number	Diff line change
`@@ -60,24 +60,37 @@ public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(TVal[,] zeroBasedBackingA`
`60`	`60`	`}`
`61`	`61`	`public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns)`
`62`	`62`	`{`
`63`		`- TVal[,] zeroBased = new TVal[rows, columns];`
`64`		`- return NewOneBasedArray2D(zeroBased);`
	`63`	`+ return new OneBasedArray2DImpl<TVal>(rows, columns);`
`65`	`64`	`}`
	`65`	`+ public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, Func<int, int, TVal> initialiser)`
	`66`	`+ {`
	`67`	`+ IOneBasedArray2D<TVal> array = new OneBasedArray2DImpl<TVal>(rows, columns);`
	`68`	`+ return array.Map((i, j, _) => initialiser(i, j));`
	`69`	`+ }`
	`70`	`+ public IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, TVal initialValue) =>`
	`71`	`+ NewOneBasedArray2D(rows, columns, (i, j) => initialValue);`
`66`	`72`
`67`	`73`	`public IOneBasedArray<TVal> NewOneBasedArray<TVal>(TVal[] zeroBasedBackingArray)`
`68`	`74`	`{`
`69`	`75`	`return new OneBasedArrayImpl<TVal>(zeroBasedBackingArray);`
`70`	`76`	`}`
`71`	`77`
`72`		`- public ISequentialIntProvider NewSequentialIntProvider(int start, int step)`
	`78`	`+ public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size)`
`73`	`79`	`{`
`74`		`- return new SequentialIntProviderImpl(start, step);`
	`80`	`+ return new OneBasedArrayImpl<TVal>(size);`
	`81`	`+ }`
	`82`	`+ public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, Func<int, TVal> initialiser)`
	`83`	`+ {`
	`84`	`+ IOneBasedArray<TVal> array = new OneBasedArrayImpl<TVal>(size);`
	`85`	`+ return array.Map((i, x) => initialiser(i));`
`75`	`86`	`}`
`76`	`87`
`77`		`- public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size)`
	`88`	`+ public IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, TVal initialValue) =>`
	`89`	`+ NewOneBasedArray(size, i => initialValue);`
	`90`	`+`
	`91`	`+ public ISequentialIntProvider NewSequentialIntProvider(int start, int step)`
`78`	`92`	`{`
`79`		`- TVal[] zeroBased = new TVal[size];`
`80`		`- return NewOneBasedArray(zeroBased);`
	`93`	`+ return new SequentialIntProviderImpl(start, step);`
`81`	`94`	`}`
`82`	`95`
`83`	`96`	`public IFileDecorator NewFileDecorator() => new FileDecoratorImpl();`
Original file line number	Diff line number	Diff line change
`@@ -49,5 +49,9 @@ public interface ICsharpExtrasApi`
`49`	`49`	`ICurryDictionary<TKey, TVal> NewCurryDictionary<TKey, TVal>(int arity);`
`50`	`50`	`ICurryDictionary<TKey, TVal> NewCurryDictionary<TKey, TVal>(PositiveInteger arity);`
`51`	`51`	`ISequentialIntProvider NewSequentialIntProvider(int start, int step);`
	`52`	`+ IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, Func<int, int, TVal> initialiser);`
	`53`	`+ IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, Func<int, TVal> initialiser);`
	`54`	`+ IOneBasedArray2D<TVal> NewOneBasedArray2D<TVal>(int rows, int columns, TVal initialValue);`
	`55`	`+ IOneBasedArray<TVal> NewOneBasedArray<TVal>(int size, TVal initialValue);`
`52`	`56`	`}`
`53`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,10 @@ public OneBasedArrayImpl(TVal[] zeroBasedBackingArray)`
`17`	`17`	`_backingArray = zeroBasedBackingArray;`
`18`	`18`	`}`
`19`	`19`
	`20`	`+ public OneBasedArrayImpl(int size) : this(new TVal[size])`
	`21`	`+ {`
	`22`	`+ }`
	`23`	`+`
`20`	`24`	`public TVal this[int oneBasedIndex]`
`21`	`25`	`{`
`22`	`26`	`get`
`@@ -138,6 +142,13 @@ public IOneBasedArray<TResult> Map<TResult>(Func<TVal, TResult> mapper)`
`138`	`142`	`return new OneBasedArrayImpl<TResult>(zeroBasedMapped);`
`139`	`143`	`}`
`140`	`144`
	`145`	`+ public IOneBasedArray<TResult> Map<TResult>(Func<int, TVal, TResult> mapper)`
	`146`	`+ {`
	`147`	`+ TResult zeroBasedFunc(int i, TVal x) => mapper(i + 1, x);`
	`148`	`+ TResult[] zeroBasedMapped = ZeroBasedEquivalent.Map(zeroBasedFunc);`
	`149`	`+ return new OneBasedArrayImpl<TResult>(zeroBasedMapped);`
	`150`	`+ }`
	`151`	`+`
`141`	`152`	`public IDictionary<TVal, IList<int>> FindDuplicateIndices()`
`142`	`153`	`{`
`143`	`154`	`IDictionary<TVal, IList<int>> zeroBasedDuplicates = ZeroBasedEquivalent.FindDuplicateIndices();`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,10 @@ public OneBasedArray2DImpl(TVal[,] backingArray)`
`26`	`26`	`ZeroBasedEquivalent = backingArray;`
`27`	`27`	`}`
`28`	`28`
	`29`	`+ public OneBasedArray2DImpl(int rows, int columns) : this(new TVal[rows, columns])`
	`30`	`+ {`
	`31`	`+ }`
	`32`	`+`
`29`	`33`	`public TVal this[int oneBasedIndex0, int oneBasedIndex1]`
`30`	`34`	`{`
`31`	`35`	`get`
`@@ -66,6 +70,13 @@ public IOneBasedArray2D<TResult> Map<TResult>(Func<TVal, TResult> mapper)`
`66`	`70`	`return new OneBasedArray2DImpl<TResult>(mapped);`
`67`	`71`	`}`
`68`	`72`
	`73`	`+ public IOneBasedArray2D<TResult> Map<TResult>(Func<int, int, TVal, TResult> mapper)`
	`74`	`+ {`
	`75`	`+ TResult zeroBasedFunc(int i, int j, TVal x) => mapper(i + 1, j + 1, x);`
	`76`	`+ TResult[,] zeroBasedMapped = ZeroBasedEquivalent.Map(zeroBasedFunc);`
	`77`	`+ return new OneBasedArray2DImpl<TResult>(zeroBasedMapped);`
	`78`	`+ }`
	`79`	`+`
`69`	`80`	`public IOneBasedArray2D<TResult> ZipArray<TOther, TResult>(Func<TVal, TOther, TResult> zipper, IOneBasedArray2D<TOther> other)`
`70`	`81`	`{`
`71`	`82`	`TResult[,] zipped = ZeroBasedEquivalent.ZipArray(zipper, other.ZeroBasedEquivalent);`
Original file line number	Diff line number	Diff line change
`@@ -171,6 +171,17 @@ public static int Count<TVal>(this TVal[,] array, Func<TVal, bool> checkerFuncti`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`public static TResult[,] Map<TVal, TResult>(this TVal[,] array, Func<TVal, TResult> mapper)`
	`174`	`+ {`
	`175`	`+ TResult func(int i, int j, TVal x) => mapper(x);`
	`176`	`+ return array.Map(func);`
	`177`	`+ }`
	`178`	`+`
	`179`	`+ /// <summary>`
	`180`	`+ /// Creates a new array, populated by mapping the values/indices of the old array using a mapper function.`
	`181`	`+ /// </summary>`
	`182`	`+ /// <param name="mapper">A function which maps an element and its row/column indices in the original array to an element in the new array</param>`
	`183`	`+ /// <returns>A new array, whose values are the result of applying the mapper function to the associated element in the source array & its row/column indices.</returns>`
	`184`	`+ public static TResult[,] Map<TVal, TResult>(this TVal[,] array, Func<int, int, TVal, TResult> mapper)`
`174`	`185`	`{`
`175`	`186`	`int length0 = array.GetLength(0);`
`176`	`187`	`int length1 = array.GetLength(1);`
`@@ -179,7 +190,7 @@ public static int Count<TVal>(this TVal[,] array, Func<TVal, bool> checkerFuncti`
`179`	`190`	`{`
`180`	`191`	`for (int j = 0; j < length1; j++)`
`181`	`192`	`{`
`182`		`- resultArray[i, j] = mapper(array[i, j]);`
	`193`	`+ resultArray[i, j] = mapper(i, j, array[i, j]);`
`183`	`194`	`}`
`184`	`195`	`}`
`185`	`196`	`return resultArray;`