Merge pull request #307 from Plankton555/feature/np_cumsum

Feature/np cumsum

Author: Nucs

src/NumSharp.Core/Math/NDArray.cumsum.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NumSharp
+{
+    public partial class NDArray
+    {
+        /// <summary>
+        /// Return the cumulative sum of the elements along a given axis.
+        /// </summary>
+        /// <param name="axis">Axis along which the cumulative sum is computed. The default (-1) is to compute the cumsum over the flattened array.</param>
+        /// <param name="dtype">Type of the returned array and of the accumulator in which the elements are summed. If dtype is not specified, it defaults to the dtype of a, unless a has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used.</param>
+        /// <returns>A new array holding the result is returned unless out is specified, in which case a reference to out is returned. The result has the same size as a, and the same shape as a if axis is not None or a is a 1-d array.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.cumsum.html</remarks>
+        public NDArray cumsum(int axis = -1, Type dtype = null)
+        {
+            return np.cumsum(this, axis, dtype);
+        }
+    }
+
+    public static partial class np
+    {
+        /// <summary>
+        /// Return the cumulative sum of the elements along a given axis.
+        /// </summary>
+        /// <param name="arr">Input array.</param>
+        /// <param name="axis">Axis along which the cumulative sum is computed. The default (-1) is to compute the cumsum over the flattened array.</param>
+        /// <param name="dtype">Type of the returned array and of the accumulator in which the elements are summed. If dtype is not specified, it defaults to the dtype of a, unless a has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used.</param>
+        /// <returns>A new array holding the result is returned unless out is specified, in which case a reference to out is returned. The result has the same size as a, and the same shape as a if axis is not None or a is a 1-d array.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.cumsum.html</remarks>
+        public static NDArray cumsum(NDArray arr, int axis = -1, Type dtype = null)
+        {
+            if (axis > -1)
+            {
+                // TODO currently no support for multidimensional a
+                throw new NotImplementedException();
+            }
+            NDArray cs = np.zeros(arr.shape[0]);
+            cs[0] = arr[0];
+            for (int i = 1; i < arr.shape[0]; i++)
+            {
+                cs[i] = cs[i - 1] + arr[i];
+            }
+            return cs;
+        }
+    }
+}

test/NumSharp.UnitTest/Math/NDArray.cumsum.Test.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using FluentAssertions;
+
+namespace NumSharp.UnitTest.Maths
+{
+    [TestClass]
+    public class NDArrayCumsumTest : TestClass
+    {
+        [TestMethod]
+        public void CumsumStaticFunctionTest()
+        {
+            NDArray arr = new double[] { 0, 1, 4, 2, 5, 6, 2 };
+            NDArray expected = new double[] { 0, 1, 5, 7, 12, 18, 20 };
+
+            NDArray actual = np.cumsum(arr);
+
+            actual.Array.Should().BeEquivalentTo(expected.Array);
+        }
+
+        [TestMethod]
+        public void CumsumMemberFunctionTest()
+        {
+            NDArray arr = new double[] { 0, 1, 4, 2, 5, 6, 2 };
+            NDArray expected = new double[] { 0, 1, 5, 7, 12, 18, 20 };
+
+            NDArray actual = arr.cumsum();
+
+            actual.Array.Should().BeEquivalentTo(expected.Array);
+        }
+
+        [TestMethod]
+        public void Cumsum2dTest()
+        {
+            NDArray arr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
+            NDArray expected = new int[] { 1, 3, 6, 10, 15, 21 };
+
+            NDArray actual = np.cumsum(arr);
+
+            actual.Array.Should().BeEquivalentTo(expected.Array);
+        }
+
+        [TestMethod]
+        public void Cumsum2dDtypeTest()
+        {
+            NDArray arr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
+            NDArray expected = new float[] { 1, 3, 6, 10, 15, 21 };
+
+            NDArray actual = np.cumsum(arr, dtype: typeof(float));
+
+            actual.Array.Should().BeEquivalentTo(expected.Array);
+        }
+
+        [TestMethod]
+        public void Cumsum2dAxisRowsTest()
+        {
+            NDArray arr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
+            NDArray expected = new int[,] { { 1, 2, 3 }, { 5, 7, 9 } };
+
+            NDArray actual = np.cumsum(arr, axis: 0);
+
+            for (int i = 0; i < actual.shape[0]; i++)
+            {
+                for (int j = 0; j < actual.shape[1]; j++)
+                {
+                    Assert.AreEqual((int)expected[i, j], (int)actual[i, j]);
+                }
+            }
+        }
+
+        [TestMethod]
+        public void Cumsum2dAxisColsTest()
+        {
+            NDArray arr = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
+            NDArray expected = new int[,] { { 1, 3, 6 }, { 4, 9, 15 } };
+
+            NDArray actual = np.cumsum(arr, axis: 1);
+
+            for (int i = 0; i < actual.shape[0]; i++)
+            {
+                for (int j = 0; j < actual.shape[1]; j++)
+                {
+                    Assert.AreEqual((int)expected[i, j], (int)actual[i, j]);
+                }
+            }
+        }
+    }
+}