Added slicing

Oceania2018 · Oceania2018 · commit fecaefb90342 · 2018-11-13T19:52:44.000-06:00
Updated README
diff --git a/README.md b/README.md
@@ -17,14 +17,20 @@ NumSharp has implemented the arange, array, max, min, reshape, normalize, unique
 The NumPy class is a high-level abstraction of NDArray that allows NumSharp to be used in the same way as Python's NumPy, minimizing API differences caused by programming language features, allowing .NET developers to maximize Utilize a wide range of NumPy code resources to seamlessly translate python code into .NET code.
 
 * NumPy
+  * absolute
+  * amax
   * amin
   * arange
   * array
   * hstack
   * linspace
   * random
+    * normal
     * randint
+    * randn
+    * stardard_normal
   * reshape
+  * sin
   * vstack
   * zeros
   
diff --git a/src/NumSharp/NumPy.cs b/src/NumSharp/NumPy.cs
@@ -15,14 +15,14 @@ public NDArray<double> absolute(NDArray<double> np)
             return np.Absolute();
         }
 
-        public NDArray<double> amin(NDArray<double> np, int? axis = null)
+        public NDArray<double> amax(NDArray<double> np, int? axis = null)
         {
-            return np.AMin(axis);
+            return np.AMax(axis);
         }
 
-        public NDArray<double> amax(NDArray<double> np, int? axis = null)
+        public NDArray<double> amin(NDArray<double> np, int? axis = null)
         {
-            return np.AMax(axis);
+            return np.AMin(axis);
         }
 
         public NDArray<T> arange(int stop)
@@ -121,6 +121,11 @@ public NDArray<int> reshape(NDArray<int> np, params int[] shape)
             return np;
         }
 
+        public NDArray<double> sin(NDArray<double> nd)
+        {
+            return nd.sin();
+        }
+
         public NDArray<double> vstack(params NDArray<double>[] nps)
         {
             var n = new NDArray<double>();
diff --git a/src/NumSharp/Selection/NDArray.Slicing.cs b/src/NumSharp/Selection/NDArray.Slicing.cs
@@ -6,6 +6,37 @@ namespace NumSharp
 {
     public partial class NDArray<T>
     {
-        
+        public NDArray<T>[] this[Slice select]
+        {
+            get
+            {
+                var list = new List<NDArray<T>>();
+
+                int[] shape = new int[Shape.Length];
+                for (int i = 0; i < Shape.Length; i++)
+                {
+                    if (i == 0)
+                    {
+                        shape[i] = select.Step;
+                    }
+                    else
+                    {
+                        shape[i] = Shape[i];
+                    }
+                }
+
+                for (int s = select.Start; s< select.Stop; s+= select.Step)
+                {
+                    var n = new NDArray<T>();
+                    Span<T> data = Data;
+                    n.Data = data.Slice(s, select.Step).ToArray();
+                    n.Shape = new Shape(shape);
+
+                    list.Add(n);
+                }
+
+                return list.ToArray();
+            }
+        }
     }
 }
diff --git a/src/NumSharp/Slice.cs b/src/NumSharp/Slice.cs
@@ -10,18 +10,29 @@ namespace NumSharp
     /// </summary>
     public class Slice
     {
-        private int start;
-        private int stop;
-        private int step;
+        public int Start { get; set; }
+        public int Stop { get; set; }
+        public int Step { get; set; }
 
+        public int Length => Stop - Start;
+
+        /// <summary>
+        /// start, stop, step
+        /// </summary>
+        /// <param name="p"></param>
         public Slice(params int[] p)
         {
             switch (p.Length)
             {
+                case 2:
+                    Start = p[0];
+                    Stop = p[1];
+                    Step = 1;
+                    break;
                 case 3:
-                    start = p[0];
-                    stop = p[1];
-                    step = p[2];
+                    Start = p[0];
+                    Stop = p[1];
+                    Step = p[2];
                     break;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -15,14 +15,14 @@ public NDArray<double> absolute(NDArray<double> np)`
`15`	`15`	`return np.Absolute();`
`16`	`16`	`}`
`17`	`17`
`18`		`- public NDArray<double> amin(NDArray<double> np, int? axis = null)`
	`18`	`+ public NDArray<double> amax(NDArray<double> np, int? axis = null)`
`19`	`19`	`{`
`20`		`- return np.AMin(axis);`
	`20`	`+ return np.AMax(axis);`
`21`	`21`	`}`
`22`	`22`
`23`		`- public NDArray<double> amax(NDArray<double> np, int? axis = null)`
	`23`	`+ public NDArray<double> amin(NDArray<double> np, int? axis = null)`
`24`	`24`	`{`
`25`		`- return np.AMax(axis);`
	`25`	`+ return np.AMin(axis);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public NDArray<T> arange(int stop)`
`@@ -121,6 +121,11 @@ public NDArray<int> reshape(NDArray<int> np, params int[] shape)`
`121`	`121`	`return np;`
`122`	`122`	`}`
`123`	`123`
	`124`	`+ public NDArray<double> sin(NDArray<double> nd)`
	`125`	`+ {`
	`126`	`+ return nd.sin();`
	`127`	`+ }`
	`128`	`+`
`124`	`129`	`public NDArray<double> vstack(params NDArray<double>[] nps)`
`125`	`130`	`{`
`126`	`131`	`var n = new NDArray<double>();`