NDArray, string api: Perf-ops

- Fixed small type

Author: Nucs

src/NumSharp.Core/Backends/NDArray.String.cs

@@ -47,24 +47,24 @@ public string GetString(params int[] indices)
 
                 Debug.Assert(typecode == NPTypeCode.Char);
 
-                UnmanagedStorage arr = Storage.GetData(indices);
-                Debug.Assert(arr.Shape.NDim == 1);
+                UnmanagedStorage src = Storage.GetData(indices);
+                Debug.Assert(src.Shape.NDim == 1);
 
-                if (!Shape.IsContagious)
+                if (!Shape.IsContiguous)
                 {
                     //this works faster than cloning.
-                    var ret = new string('\0', arr.Count);
+                    var ret = new string('\0', src.Count);
                     fixed (char* retChars = ret)
                     {
-                        var dst = new UnmanagedStorage(new ArraySlice<char>(new UnmanagedMemoryBlock<char>(retChars, ret.Length)), arr.Shape.Clean());
-                        MultiIterator.Assign(dst, arr);
+                        var dst = new UnmanagedStorage(new ArraySlice<char>(new UnmanagedMemoryBlock<char>(retChars, ret.Length)), src.Shape.Clean());
+                        MultiIterator.Assign(dst, src);
                     }
 
                     return ret;
                 }
 
                 //new string always performs a copy, there is no need to keep reference to arr's unmanaged storage.
-                return new string((char*)arr.Address, 0, arr.Count);
+                return new string((char*)src.Address, 0, src.Count);
             }
         }
 
@@ -81,13 +81,13 @@ public void SetString(string value, params int[] indices)
 
             unsafe
             {
-                if (Shape.IsContagious)
+                if (Shape.IsContiguous)
                 {
                     var dst = (char*)Address + Shape.GetOffset(indices);
-                    fixed (char* strChars = value)
+                    fixed (char* src = value)
                     {
-                        var src = strChars;
-                        Parallel.For(0, value.Length, i => *(dst + i) = *(src + i));
+                        var len = sizeof(char) * value.Length;
+                        Buffer.MemoryCopy(src, dst, len, len);
                     }
                 }
                 else

src/NumSharp.Core/Creation/np.array.cs

@@ -61,7 +61,6 @@ public static NDArray array(string chars)
                 throw new ArgumentNullException(nameof(chars));
             if (chars.Length==0)
                 return new NDArray(NPTypeCode.Char);
-            return new NDArray(ArraySlice.FromArray(chars.ToArray()), Shape.Vector(chars.Length));
 
             unsafe
             {

src/NumSharp.Core/View/Shape.cs

@@ -28,7 +28,7 @@ public bool IsSliced
         /// <summary>
         ///     Does this Shape represents a non-sliced and non-broadcasted hence contagious unmanaged memory?
         /// </summary>
-        public bool IsContagious
+        public bool IsContiguous
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get => !IsSliced && !IsBroadcasted;

test/NumSharp.UnitTest/Backends/Unmanaged/StringApiTests.cs

@@ -40,7 +40,27 @@ public void GetString()
             str.Should().BeOfType<char>().And.BeShaped(5 * 5);
             str = str.reshape(5, 5);
             str.GetString(3).Should().Be("lllll");
-            new Action(() => { var _ = str.GetString(3, 1); }).Should().Throw<ArgumentOutOfRangeException>();
+            new Action(() =>
+            {
+                var _ = str.GetString(3, 1);
+            }).Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [TestMethod]
+        public void GetString_Sliced()
+        {
+            var str = np.repeat(np.array('h', 'e', 'l', 'l', 'o'), 5).reshape(5, 5)[":, 0"];
+            str.Should().BeOfType<char>().And.BeShaped(5).And.BeOfValues('h', 'e', 'l', 'l', 'o').And.BeSliced();
+            str.GetString().Should().Be("hello");
+        }
+        [TestMethod]
+        public void SetString_Sliced()
+        {
+            var str = np.repeat(np.array('h', 'e', 'l', 'l', 'o'), 5).reshape(5, 5)[":, 0"];
+            str.Should().BeOfType<char>().And.BeShaped(5).And.BeOfValues('h', 'e', 'l', 'l', 'o').And.BeSliced();
+            str.GetString().Should().Be("hello");
+            str.SetString("kekek");
+            str.Should().BeOfValues("kekek".ToCharArray().Cast<object>().ToArray());
         }
 
         [TestMethod]