Doc : go on with docs - explained NDArray ideas

Author: dotchris90

docfx_project/articles/NDArray.Creation.md

@@ -7,50 +7,58 @@ Before we do some fancy numeric stuff or even machine learning we have to clear
 Since NDArray is the key class in SciSharp stack there must be numerous possibilities how to generate this arrays. And yes that’s the case. 
 
 Maybe first of all we should see the dump way – which can be always used but is not too user friendly.  
+In this example we access the Storage property directly - one more reason to avoid it. 
 
 **Dump way**
 
 ```CSHARP
-// first constructor with data type 
-// you also specify the generic type of the NDArray
-var np = new NDArray(typeof(double));
-
-// set 9 elements into this array
+// first constructor with data type and shape (here 3x3 matrix)
+var nd = new NDArray(typeof(double),3,3);
+            
+// set 9 elements into the storage of this array.
 np.Storage.SetData(new double[] {1,2,3,4,5,6,7,8,9});
-
-// shape it to a 3x3 matrix 
-np.Storage.Shape = new Shape(3,3);
 ```
 
 Ok looks not too difficult. But also not too userfriendly. 
 
-We create an empty NDArray< double >, fill it with 9 elements and shape it to 3x3 matrix. 
-
-At this point we could shape it also to a 1x9 vector but we shaped it to a 3x3. 
+We create an empty NDArray with 3x3 shape, fill it with 9 elements.
+We followed the row wise matrix layour by default.
 
-So with this 3x3 shaped NDArray we can do matrix multiplication but with a 1x9 we could not.
+So with this 3x3 shaped NDArray we can do matrix multiplication, QR decomposition, SVD, ...
 
-Always be careful with your shape and be sure what you want to do with your elements. 
+But keep in mind - always be careful with your shape and be sure what you want to do with your elements in this shape. 
 
 **Create by enumeration**
 
+The next example shows the numpy style creation.
+
 ```CSHARP
-// at this point we use a numpy class so it looks like numpy function call 
-var np = new Numpy<double>();
+using NumSharp.Core;
 
 // we take the Data / elements from an array 
-// we do not need to define the shape here
+// we do not need to define the shape here - it is automaticly shaped to 1D
 var np1 = np.array(new double[] {1,2,3,4,5,6} );
 ```
 
 Ok as we can see, this time the array was created without define the shape. 
 
 This is possible since the method expect that the double[] array shall be transformed into a NDArray directly. 
 
+**Create by implicit cast**
+
+Beside this numpy style C# offers its own flavour of creation.
+
+```CSHARP
+using NumSharp.Core;
+
+// implicit cast double[] to NDArray - dtype & shape are deduced by array type and shape
+NDArray nd = new double[]{1,2,3,4};
+```
+
 **Create by given range**
 
 ```CSHARP
-var np = new Numpy<double>();
+using NumSharp.Core;
 
 // we simple say "create an array with 10 elements"
 // start is expected to be 0 and step 1

docfx_project/articles/intro.md

@@ -1,3 +1,50 @@
 # Introduction 
 
 The following pages are for the users who want to use NumSharp. 
+
+Before you read the code examples you should read this page which explain some basis concepts. 
+An other reference can be numpy since we try our best to follow their APIs. 
+
+## NDArray, NDStorgage and Shape
+
+The 3 main classes in NumSharp are NDArray, NDStorage and Shape. 
+If you want to have a better understanding for NumSharp, you can read the following lines to see how all works together. 
+
+Let's start with the question - what is a Tensor? 
+
+From programming point of view a tensor is a multi-dimensional array (scalar, vector, matrix, ...) mostly for numerical data like int32, int64, doubles, ...  which can be accessed via indexes like np[idx], np[idx,jdx], np[idx,jdx,kdx], ... depending on its dimension. 
+
+Ok - in this sentence we got already some properties. 
+
+- a tensor is an object for storing (mostly) numerical data 
+- a tensor has a dimension 
+- the dimension decides how many indexes are necessary to access the stored data
+
+Each tensor type (dimension 1 - vector, dimension 2 - matrix, ...) has its own .NET type like double[,]. 
+
+NumSharp brings its own tensor / array type called **NDArray**.
+
+So now the question - .NET offers already multi-dimensional arrays - why a new array type?
+
+NumSharps NDArray offers the capability of storing any tensor (independent of dimension!) into its internal storage. 
+So NumSharps NDArray can store a vector, a matrix or sth with dimension 5 and higher. This is not possible with .NET arrays since each tensor type is a different class. 
+
+Now the next question - how a NDArray can do this? 
+
+First of all we need to be a little bit more abstract. Why we use tensors? Because we want to store data and we want to get them. How we get and set them? We get and set via indexes (which are always integers). So just this data are important and the corresponding indexes.
+
+With this in mind we easily can understand the NDStorage of NumSharp. 
+
+NDStorage is an object which stores the data of a tesor in a single 1D array. Since it is a 1D array independend of the tensor dimension NDStorage can be used for all kind of tensors. 
+
+**But hold on! How the data comes into this 1D array?**
+
+NDStorage has a property called "shape". The shape is a small but important class in NumSharp. It stores the dimensions and most important! it determines which element in the 1D array is selected by given indexes. 
+
+
+
+
+
+
+
+

src/NumSharp.Core/Generics/Casting/NdArray.Implicit.cs

@@ -0,0 +1,23 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NumSharp.Core.Extensions;
+using NumSharp.Core;
+
+namespace NumSharp.UnitTest
+{
+    [TestClass]
+    public class DocTest
+    {
+        [TestMethod]
+        public void Dump()
+        {
+            var nd = new NDArray(typeof(double),3,3);
+            nd.Storage.SetData(new double[] {1,2,3,4,5,6,7,8,9} );
+
+            
+        }
+            
+    }
+}