Revamped basic np.unique

Author: Nucs

src/NumSharp.Core/APIs/np.array_manipulation.cs

@@ -20,14 +20,11 @@ public static NDArray transpose(NDArray x, int[] axes = null)
             => x.TensorEngine.Transpose(x, axes: axes);
 
         /// <summary>
-        /// Find the unique elements of an array.
-        /// 
-        /// Returns the sorted unique elements of an array.There are three optional outputs in addition to the unique elements:
-        /// * the indices of the input array that give the unique values
-        /// * the indices of the unique array that reconstruct the input array
-        /// * the number of times each unique value comes up in the input array
+        ///     Find the unique elements of an array.
         /// </summary>
-        public static NDArray unique<T>(NDArray a)
-            => a.unique<T>();
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html</remarks>
+        public static NDArray unique(NDArray a)
+            => a.unique();
+
     }
 }

src/NumSharp.Core/Backends/NDArray.cs

@@ -273,7 +273,6 @@ protected internal unsafe void* Address
 
         public int[] strides => Storage.Shape.Strides;
 
-        //TODO! when reshaping a slice is done - this should not clone in case of a sliced shape.
         /// <summary>
         ///     A 1-D iterator over the array.
         /// </summary>

src/NumSharp.Core/Manipulation/NDArray.unique.cs

@@ -1,7 +1,41 @@
-namespace NumSharp
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using NumSharp.Backends;
+using NumSharp.Backends.Unmanaged;
+using NumSharp.Utilities;
+
+namespace NumSharp
 {
     public partial class NDArray
     {
+        public NDArray unique()
+        {
+            switch (typecode)
+            {
+#if _REGEN
+	        %foreach supported_dtypes,supported_dtypes_lowercase%
+	        case NPTypeCode.#1: return unique<#2>();
+            %
+            default: throw new NotSupportedException();
+#else
+                case NPTypeCode.Boolean: return unique<bool>();
+                case NPTypeCode.Byte: return unique<byte>();
+                case NPTypeCode.Int16: return unique<short>();
+                case NPTypeCode.UInt16: return unique<ushort>();
+                case NPTypeCode.Int32: return unique<int>();
+                case NPTypeCode.UInt32: return unique<uint>();
+                case NPTypeCode.Int64: return unique<long>();
+                case NPTypeCode.UInt64: return unique<ulong>();
+                case NPTypeCode.Char: return unique<char>();
+                case NPTypeCode.Double: return unique<double>();
+                case NPTypeCode.Single: return unique<float>();
+                case NPTypeCode.Decimal: return unique<decimal>();
+                default: throw new NotSupportedException();
+#endif
+            }
+        }
+
         /// <summary>
         /// Find the unique elements of an array.
         /// 
@@ -12,16 +46,35 @@ public partial class NDArray
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
-        public NDArray unique<T>()
+        protected NDArray unique<T>() where T : unmanaged
         {
-            return null;
-            //var nd = new NDArray(dtype);
-            //var data = Storage.GetData<T>().Distinct().ToArray();
-            //nd.Storage.ReplaceData(data);
+            unsafe
+            {
+                var hashset = new Hashset<T>();
+                if (Shape.IsContiguous)
+                {
+                    var src = (T*)this.Address;
+                    int len = this.size;
+                    for (int i = 0; i < len; i++) //we do not use Parellel.For because of the internal lock
+                        hashset.Add(src[i]);
 
-            //nd.Storage.Reshape(data.Length);
+                    var ret = new NDArray(typeof(T), Shape.Vector(hashset.Count));
+                    Hashset<T>.CopyTo(hashset, (ArraySlice<T>)ret.Array);
+                    return ret;
+                }
+                else
+                {
+                    int len = this.size;
+                    var flat = this.flat;
+                    var src = (T*)flat.Address;
+                    Func<int, int> getOffset = flat.Shape.GetOffset_1D;
+                    Parallel.For(0, len, i => hashset.Add(src[getOffset(i)])); //we use parallel to speed up offset computation
 
-            //return nd;
+                    var dst = new NDArray(typeof(T), Shape.Vector(hashset.Count));
+                    Hashset<T>.CopyTo(hashset, (ArraySlice<T>)dst.Array);
+                    return dst;
+                }
+            }
         }
     }
 }

test/NumSharp.UnitTest/Manipulation/NDArray.unique.Test.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NumSharp.Backends;
+using NumSharp.UnitTest.Utilities;
+
+namespace NumSharp.UnitTest.Manipulation
+{
+    [TestClass]
+    public class NDArray_unique_Test : TestClass
+    {
+        [TestMethod]
+        public void Case1()
+        {
+            arange(10).unique()
+                .Should().BeShaped(10).And.BeOfValues(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        }
+
+        [TestMethod]
+        public void Case2()
+        {
+            np.repeat(arange(10), 10).reshape(10,10).unique()
+                .Should().BeShaped(10).And.BeOfValues(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        }
+
+        [TestMethod]
+        public void Case2_Sliced()
+        {
+            var arr = np.repeat(arange(10), 10).reshape(10, 10)[":, 0"];
+            Console.WriteLine((string)arr);
+            Console.WriteLine((string)arr.unique());
+            arr.unique().Should().BeShaped(10).And.BeOfValues(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        }
+    }
+}