SciSharp · Nucs · Aug 6, 2019 · Jul 23, 2019 · Jul 23, 2019 · Jul 23, 2019
diff --git a/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.Cast.cs b/src/NumSharp.Core/Backends/Default/ArrayManipulation/Default.Cast.cs
@@ -36,11 +36,15 @@ public override NDArray Cast(NDArray nd, NPTypeCode dtype, bool copy)
                 //casting needed
                 if (copy)
                 {
+                    if (nd.Shape.IsSliced)
+                        nd = clone();
+
                     return new NDArray(new UnmanagedStorage(ArraySlice.FromMemoryBlock(nd.Array.Cast(dtype), false), nd.Shape));
                 }
                 else
                 {
-                    nd.Storage = new UnmanagedStorage(ArraySlice.FromMemoryBlock(nd.Array.Cast(dtype), false), nd.Shape);
+                    var storage = nd.Shape.IsSliced ? nd.Storage.Clone() : nd.Storage;
+                    nd.Storage = new UnmanagedStorage(ArraySlice.FromMemoryBlock(storage.InternalArray.Cast(dtype), false), storage.Shape);
                     return nd;
                 }
             }

diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedMemoryBlock.Casting.cs
diff --git a/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs b/src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs
@@ -1359,6 +1359,7 @@ public IArraySlice GetData()
         /// <returns>reference to cloned storage as System.Array</returns>
         public IArraySlice CloneData()
         {
+            //TODO! this should clone based on the slice!
             return InternalArray.Clone();
         }
 
@@ -1369,7 +1370,7 @@ public IArraySlice CloneData()
         /// <typeparam name="T">The type that is expected.</typeparam>
         public ArraySlice<T> AsArray<T>() where T : unmanaged
         {
-            //if (!typeof(T).IsValidNPType())
+            //TODO! this should clone based on the slice!
             return (ArraySlice<T>)InternalArray;
         }
 
@@ -1380,6 +1381,7 @@ public ArraySlice<T> AsArray<T>() where T : unmanaged
         /// <returns>reference to cloned storage as <see cref="ArraySlice{T}"/></returns>
         public ArraySlice<T> CloneData<T>() where T : unmanaged
         {
+            //TODO! this should clone based on the slice!
             return (ArraySlice<T>)InternalArray.Clone();
         }
 
@@ -1392,15 +1394,15 @@ public ArraySlice<T> CloneData<T>() where T : unmanaged
         public ArraySlice<T> GetData<T>() where T : unmanaged
         {
             if (!typeof(T).IsValidNPType())
-            {
                 throw new NotSupportedException($"Type {typeof(T).Name} is not a valid np.dtype");
-            }
 
             //if (typeof(T).Name != _DType.Name)
             //{
             //    Console.WriteLine($"Warning: GetData {typeof(T).Name} is not {_DType.Name} of storage.");
             //}
 
+            //TODO! this should clone based on the slice!
+
             var internalArray = InternalArray;
             if (internalArray is ArraySlice<T> ret)
                 return ret;
@@ -1462,16 +1464,20 @@ public void SetData(object value, params int[] indices)
                 return;
             }
 
+            //TODO! this should support slice!
+
             SetIndex(value, _shape.GetIndexInShape(indices));
         }
 
         public unsafe void SetIndex<T>(T value, int index) where T : unmanaged
         {
+            //TODO! this should support slice!
             *((T*)this.Address + index) = value;
         }
 
         public unsafe void SetIndex(object value, int index)
         {
+            //TODO! this should support slice!
             switch (_typecode)
             {
 #if _REGEN
@@ -1569,6 +1575,7 @@ public unsafe void SetIndex(object value, int index)
         [MethodImpl((MethodImplOptions)768)]
         public unsafe T GetIndex<T>(int index) where T : unmanaged
         {
+            //TODO! this should support slice!
             return *((T*)Address + index);
         }
 
@@ -1584,6 +1591,7 @@ public unsafe T GetIndex<T>(int index) where T : unmanaged
         /// </remarks>
         public void SetData(NDArray value, params int[] indices)
         {
+            //TODO! this should support slice!
             if (ReferenceEquals(value, null))
                 throw new ArgumentNullException(nameof(value));
 
@@ -1749,7 +1757,9 @@ public void ReplaceData(NDArray nd)
             if (_typecode == NPTypeCode.Empty)
                 throw new NotSupportedException($"{_dtype.Name} as a dtype is not supported.");
 
-            SetInternalArray(nd.Array);
+            //todo! what if nd is sliced
+
+            SetInternalArray(nd.Shape.IsSliced ? nd.Storage.CloneData() : nd.Array);
         }
 
         /// <summary>
@@ -1908,6 +1918,7 @@ public UnmanagedStorage GetView(params Slice[] slices)
         public UnmanagedStorage Clone()
         {
             //TODO! When the shape is sliced, clone only slice data.
+            //TODO! after we clone a slice, shape must be cleaned from slices!
             var puffer = Engine.GetStorage(_dtype);
             puffer.Allocate(InternalArray.Clone(), _shape);
             return puffer;

diff --git a/src/NumSharp.Core/Creation/NdArray.VStack.cs b/src/NumSharp.Core/Creation/NdArray.VStack.cs
@@ -2,42 +2,22 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using NumSharp.Extensions;
 
 namespace NumSharp
 {
     public partial class NDArray
     {
-        public NDArray vstack<T>(params NDArray[] nps)
+        /// <summary>
+        ///     Stack arrays in sequence vertically (row wise).<br></br>
+        ///     This is equivalent to concatenation along the first axis after 1-D arrays of shape(N,) have been reshaped to(1, N). Rebuilds arrays divided by vsplit.
+        /// </summary>
+        /// <typeparam name="T">The type dtype to return.</typeparam>
+        /// <param name="tup">The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.</param>
+        /// <returns>https://docs.scipy.org/doc/numpy/reference/generated/numpy.vstack.html</returns>
+        public NDArray vstack<T>(params NDArray[] tup) where T : unmanaged
         {
-            return null;
-            //if (nps == null || nps.Length == 0)
-            //    throw new Exception("Input arrays can not be empty");
-
-            //var list = this.Storage.GetData<T>().ToList();
-
-            //NDArray np = new NDArray(dtype);
-
-            //foreach (NDArray ele in nps)
-            //{
-            //    if (nps[0].shape != ele.shape)
-            //        throw new Exception("Arrays mush have same shapes");
-
-            //    list.AddRange(ele.Storage.GetData<T>());
-            //}
-
-            //np.Storage.ReplaceData(list.ToArray());
-
-            //if (nps[0].ndim == 1)
-            //{
-            //    np.Storage.Reshape(new int[] { nps.Length +1, nps[0].shape[0] });
-            //}
-            //else
-            //{
-            //    int[] shapes = nps[0].shape;
-            //    shapes[0] *= nps.Length + 1;
-            //    np.Storage.Reshape(shapes) ;
-            //}
-            //return np;
+            return np.vstack<T>(this.Yield().Concat(tup).ToArray());
         }
     }
 }
diff --git a/src/NumSharp.Core/Creation/np.vstack.cs b/src/NumSharp.Core/Creation/np.vstack.cs
@@ -1,21 +1,105 @@
 using NumSharp.Extensions;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
+using NumSharp.Backends.Unmanaged;
 
 namespace NumSharp
 {
     public static partial class np
     {
-        public static NDArray vstack<T>(params NDArray[] nps)
+        /// <summary>
+        ///     Stack arrays in sequence vertically (row wise).<br></br>
+        ///     This is equivalent to concatenation along the first axis after 1-D arrays of shape(N,) have been reshaped to(1, N). Rebuilds arrays divided by vsplit.
+        /// </summary>
+        /// <typeparam name="T">The type dtype to return.</typeparam>
+        /// <param name="tup">The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.</param>
+        /// <returns>The array formed by stacking the given arrays, will be at least 2-D.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.vstack.html</remarks>
+        public static NDArray vstack<T>(params NDArray[] tup) where T : unmanaged
         {
-            var np1 = nps[0];
+            if (tup == null || tup.Length == 0)
+                throw new Exception("Input arrays can not be empty");
 
-            var npn = new NDArray[nps.Length - 1];
-            for (int idx = 1; idx < nps.Length; idx++)
-                npn[idx - 1] = nps[idx];
+            NDArray ret = new NDArray(typeof(T), Shape.Vector(tup.Sum(n => n.size)));
+            Shape commonShape = tup[0].shape;
+            unsafe
+            {
+                var retaddr = (byte*)ret.Address;
+                int accoffset = 0;
+                foreach (NDArray curr in tup)
+                {
+                    if (commonShape != curr.Shape)
+                        throw new Exception("Arrays mush have same shapes");
+                    var data = curr.Storage.GetData<T>();
+                    var len = data.Count * data.ItemLength;
+                    Buffer.MemoryCopy(data.Address, (retaddr + accoffset), len, len);
+                    accoffset += len;
+                }
+            }
 
-            return np1.vstack<T>(npn);
+            if (commonShape.NDim == 1) //all dims are equal across all ndarrays
+            {
+                ret.Storage.Reshape(Shape.Matrix(tup.Length, commonShape[0]));
+            }
+            else
+            {
+                int[] shapes = commonShape.dimensions;
+                shapes[0] *= tup.Length;
+                ret.Storage.Reshape(new Shape(shapes));
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        ///     Stack arrays in sequence vertically (row wise).<br></br>
+        ///     This is equivalent to concatenation along the first axis after 1-D arrays of shape(N,) have been reshaped to(1, N). Rebuilds arrays divided by vsplit.
+        /// </summary>
+        /// <typeparam name="T">The type dtype to return.</typeparam>
+        /// <param name="tup">The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.</param>
+        /// <returns>The array formed by stacking the given arrays, will be at least 2-D.</returns>
+        /// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.vstack.html</remarks>
+        public static NDArray vstack(params NDArray[] tup)
+        {
+            var common_type = np._FindCommonType(tup);
+            if (tup == null || tup.Length == 0)
+                throw new Exception("Input arrays can not be empty");
+
+            NDArray ret = new NDArray(common_type, Shape.Vector(tup.Sum(n => n.size)));
+            Shape commonShape = tup[0].shape;
+            unsafe
+            {
+                var retaddr = (byte*)ret.Address;
+                int accBytesOffset = 0;
+                foreach (NDArray curr in tup)
+                {
+                    if (commonShape != curr.Shape)
+                        throw new Exception("Arrays mush have same shapes");
+                    var data = curr.Storage.InternalArray;
+                    var bytesLen = data.Count * data.ItemLength;
+                    if (data.TypeCode != common_type)
+                        data.Cast(ret.Array, bytesOffset: accBytesOffset);
+                    else
+                        Buffer.MemoryCopy(data.Address, (retaddr + accBytesOffset), bytesLen, bytesLen);
+                    accBytesOffset += bytesLen;
+                }
+            }
+
+            if (commonShape.NDim == 1) //all dims are equal across all ndarrays
+            {
+                ret.Storage.Reshape(Shape.Matrix(tup.Length, commonShape[0]));
+            }
+            else
+            {
+                int[] shapes = commonShape.dimensions;
+                shapes[0] *= tup.Length;
+                ret.Storage.Reshape(new Shape(shapes));
+            }
+
+            return ret;
         }
+
     }
 }
diff --git a/src/NumSharp.Core/Shape.cs b/src/NumSharp.Core/Shape.cs
@@ -703,14 +703,14 @@ public override string ToString()
         /// <returns>A new object that is a copy of this instance.</returns>
         object ICloneable.Clone()
         {
-            return Clone(false);
+            return Clone(true);
         }
 
         /// <summary>
         ///     Creates a complete copy of this Shape.
         /// </summary>
         /// <param name="deep">Should make a complete deep clone or a shallow if false.</param>
-        public Shape Clone(bool deep = false)
+        public Shape Clone(bool deep = true)
         {
             return deep ? new Shape(this) : this;
         }

diff --git a/test/NumSharp.UnitTest/Extensions/NdArray.VStack.Test.cs b/test/NumSharp.UnitTest/Extensions/NdArray.VStack.Test.cs
@@ -19,6 +19,7 @@ public void VStackNDArrays()
             //1D
             var n1 = np.array(new double[] {1, 2, 3});
             var n2 = np.array(new double[] {2, 3, 4});
+            var n3 = np.array(new double[] {3, 4, 5});
 
             var n = np.vstack<double>(n1, n2).MakeGeneric<double>();
 
@@ -42,6 +43,57 @@ public void VStackNDArrays()
             Assert.IsTrue(n[3, 0] == 4);
             Assert.IsTrue(n[4, 0] == 5);
             Assert.IsTrue(n[5, 0] == 6);
+
+            //3D
+            n1 = np.array(new double[][] {new double[] {1}, new double[] {2}, new double[] {3}});
+            n2 = np.array(new double[][] {new double[] {4}, new double[] {5}, new double[] {6}});
+            n3 = np.array(new double[][] {new double[] {7}, new double[] {8}, new double[] {9}});
+
+            n = np.vstack<double>(n1, n2, n3).MakeGeneric<double>();
+
+            Assert.IsTrue(n.size == (n1.size + n2.size + n3.size));
+
+            Assert.IsTrue(n[0, 0] == 1);
+            Assert.IsTrue(n[1, 0] == 2);
+            Assert.IsTrue(n[2, 0] == 3);
+            Assert.IsTrue(n[3, 0] == 4);
+            Assert.IsTrue(n[4, 0] == 5);
+            Assert.IsTrue(n[5, 0] == 6);
+            Assert.IsTrue(n[6, 0] == 7);
+            Assert.IsTrue(n[7, 0] == 8);
+            Assert.IsTrue(n[8, 0] == 9);
+        }        
+
+        [TestMethod]
+        public void VStackNDArrays_Typeless()
+        {
+            //1D
+            var n1 = np.array(new double[] {1, 2, 3});
+            var n2 = np.array(new int[] {2, 3, 4});
+            var n3 = np.array(new float[] {3, 4, 5});
+
+            var n = np.vstack(n1, n2).MakeGeneric<double>();
+
+            Assert.IsTrue(n.size == (n1.size + n2.size));
+
+            Assert.IsTrue(n[0, 0] == 1);
+            Assert.IsTrue(n[1, 0] == 2);
+            Assert.IsTrue(n[1, 2] == 4);
+
+            //2D
+            n1 = np.array(new double[][] {new double[] {1}, new double[] {2}, new double[] {3}});
+            n2 = np.array(new byte[][] {new byte[] {4}, new byte[] {5}, new byte[] {6}});
+
+            n = np.vstack(n1, n2).MakeGeneric<double>();
+
+            Assert.IsTrue(n.size == (n1.size + n2.size));
+
+            Assert.IsTrue(n[0, 0] == 1);
+            Assert.IsTrue(n[1, 0] == 2);
+            Assert.IsTrue(n[2, 0] == 3);
+            Assert.IsTrue(n[3, 0] == 4);
+            Assert.IsTrue(n[4, 0] == 5);
+            Assert.IsTrue(n[5, 0] == 6);
         }
     }
 }