More tests for cumsum, and documentation

Author: Plankton555

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

@@ -6,22 +6,41 @@ namespace NumSharp
 {
     public partial class NDArray
     {
-        public NDArray cumsum()
+        /// <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);
+            return np.cumsum(this, axis, dtype);
         }
     }
 
     public static partial class np
     {
-        public static NDArray cumsum(NDArray a)
+        /// <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)
         {
-            // TODO currently no support for multidimensional a
-            NDArray cs = np.zeros(a.shape[0]);
-            cs[0] = a[0];
-            for (int i = 1; i < a.shape[0]; i++)
+            if (axis > -1)
             {
-                cs[i] = cs[i - 1] + a[i];
+                // 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

@@ -1,38 +1,91 @@
 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 CumsumStaticTest()
+        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);
 
-            for (int i = 0; i < expected.shape[0]; i++)
-            {
-                Assert.AreEqual((double)expected[i], (double)actual[i]);
-            }
+            actual.Array.Should().BeEquivalentTo(expected.Array);
         }
 
         [TestMethod]
-        public void CumsumMemberTest()
+        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();
 
-            for (int i = 0; i < expected.shape[0]; i++)
+            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++)
             {
-                Assert.AreEqual((double)expected[i], (double)actual[i]);
+                for (int j = 0; j < actual.shape[1]; j++)
+                {
+                    Assert.AreEqual((int)expected[i, j], (int)actual[i, j]);
+                }
             }
         }
     }