remove unnecessary dependencts

Oceania2018 · Oceania2018 · commit b03442c35316 · 2019-03-21T22:10:25.000-05:00
v0.8.1 release
diff --git a/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.ValueTypes.cs b/src/NumSharp.Core/Casting/Implicit/NdArray.Implicit.ValueTypes.cs
@@ -141,12 +141,12 @@ public static implicit operator NDArray(Complex d)
             return ndArray;
         }
 
-        public static implicit operator NDArray(Quaternion d)
+        /*public static implicit operator NDArray(Quaternion d)
         {
             var ndArray = new NDArray(typeof(Quaternion),new int[0]);
             ndArray.Storage.SetData(new Quaternion[]{d});
 
             return ndArray;
-        }
+        }*/
     }
 }
diff --git a/src/NumSharp.Core/Creation/NdArray.ARange.cs b/src/NumSharp.Core/Creation/NdArray.ARange.cs
@@ -53,12 +53,12 @@ public NDArray arange(int stop, int start = 0, int step = 1)
                         dataArray = list.Select(x => (Complex)x).ToArray();
                         break;
                     }
-                case Quaternion[] dataArray:
+                /*case Quaternion[] dataArray:
                     {
                         // no performance critial operation
                         dataArray = list.Select(x => new Quaternion(new Vector3(0, 0, 0), x)).ToArray();
                         break;
-                    }
+                    }*/
                 default:
                     {
                         throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Creation/NdArray.LinSpace.cs b/src/NumSharp.Core/Creation/NdArray.LinSpace.cs
@@ -54,12 +54,12 @@ public NDArray linspace(double start, double stop,int num, bool entdpoint = true
                         dataArray[idx] = (Complex)doubleArray[idx];
                     break;
                 }
-                case Quaternion[] dataArray : 
+                /*case Quaternion[] dataArray : 
                 {
                     for(int idx = 0; idx < dataArray.Length;idx++)
                         dataArray[idx] = new Quaternion(new Vector3(0,0,0),(float)doubleArray[idx]);
                     break;
-                }
+                }*/
                 default : 
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Creation/np.array.cs b/src/NumSharp.Core/Creation/np.array.cs
@@ -30,7 +30,7 @@ public static NDArray array(Array array, Type dtype = null, int ndim = 1)
             return nd;
         }
 
-        public static NDArray array(System.Drawing.Bitmap image)
+        /*public static NDArray array(System.Drawing.Bitmap image)
         {
             var imageArray = new NDArray(typeof(Byte));
 
@@ -45,7 +45,7 @@ public static NDArray array(System.Drawing.Bitmap image)
             imageArray.Storage.SetData(bytes);
             
             return imageArray;
-        }
+        }*/
 
         public static NDArray array<T>(T[][] data)
         {
diff --git a/src/NumSharp.Core/LinearAlgebra/np.prod.cs b/src/NumSharp.Core/LinearAlgebra/np.prod.cs
@@ -9,6 +9,8 @@ public static partial class np
         public static NDArray prod(NDArray nd, int axis = -1, Type dtype = null)
         {
             NDArray result = null;
+            if (nd.size == 0) return 1;
+
             if(axis == -1)
             {
                 switch (nd.dtype.Name)
diff --git a/src/NumSharp.Core/NDStorage.cs b/src/NumSharp.Core/NDStorage.cs
@@ -144,13 +144,13 @@ protected Array _ChangeTypeOfArray(Array arrayVar, Type dtype)
                             newValues.SetValue(new System.Numerics.Complex((double)arrayVar.GetValue(idx),0),idx);
                         break;
                     }
-                    else if ( dtype == typeof(System.Numerics.Quaternion) )
+                    /*else if ( dtype == typeof(System.Numerics.Quaternion) )
                     {
                         newValues = new System.Numerics.Quaternion[arrayVar.Length];
                         for(int idx = 0;idx < arrayVar.Length;idx++)
                             newValues.SetValue(new System.Numerics.Quaternion(new System.Numerics.Vector3(0,0,0) , (float)arrayVar.GetValue(idx)),idx);
                         break;
-                    }
+                    }*/
                     else 
                     {
                         newValues = new object[arrayVar.Length];
diff --git a/src/NumSharp.Core/NumSharp.Core.csproj b/src/NumSharp.Core/NumSharp.Core.csproj
@@ -51,12 +51,6 @@
     <PackageReference Include="System.Memory" Version="4.5.1" />
   </ItemGroup>
 
-  <ItemGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^netstandard\d'))">      
-    <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
-    <PackageReference Include="Microsoft.Windows.Compatibility" Version="2.0.1" />
-    <PackageReference Include="System.Memory" Version="4.5.2" />
-  </ItemGroup>
-
   <ItemGroup Condition="$([System.Text.RegularExpressions.Regex]::IsMatch('$(TargetFramework)', '^netcoreapp\d'))">
     <PackageReference Include="Microsoft.Windows.Compatibility" Version="2.0.1" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
@@ -71,11 +65,6 @@
     <None Remove="Operations\NdArray.ElementsWise.tt" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CSharp" Version="4.5.0" />
-    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />
-  </ItemGroup>
-
   <Target Name="LogDebugInfo">
     <Message Text="Building for $(TargetFramework) on $(OS)" Importance="High" />
   </Target>
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.Equals.cs
@@ -64,7 +64,7 @@ public partial class NDArray
                     }
                     break;
                 }
-                case Quaternion[] values :
+                /*case Quaternion[] values :
                 {
                     Quaternion value = (Quaternion) obj;                 
                     for(int idx =0; idx < bools.Length;idx++)
@@ -73,7 +73,7 @@ public partial class NDArray
                             bools[idx] = true;
                     }
                     break;
-                }
+                }*/
                 default :
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Operations/Elementwise/NDArray.NotEquals.cs b/src/NumSharp.Core/Operations/Elementwise/NDArray.NotEquals.cs
@@ -64,7 +64,7 @@ public partial class NDArray
                     }
                     break;
                 }
-                case Quaternion[] values :
+                /*case Quaternion[] values :
                 {
                     Quaternion value = (Quaternion) obj;                 
                     for(int idx =0; idx < bools.Length;idx++)
@@ -73,7 +73,7 @@ public partial class NDArray
                             bools[idx] = true;
                     }
                     break;
-                }
+                }*/
                 default :
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Operations/Elementwise/NdArray.Addition.cs b/src/NumSharp.Core/Operations/Elementwise/NdArray.Addition.cs
@@ -192,7 +192,7 @@ public partial class NDArray
 				    break;
 				}
 
-				case System.Numerics.Quaternion[] resArr : 
+				/*case System.Numerics.Quaternion[] resArr : 
 				{
 				    System.Numerics.Quaternion[] np1Array = np1SysArr as System.Numerics.Quaternion[];
 				    System.Numerics.Quaternion[] np2Array = np2SysArr as System.Numerics.Quaternion[];
@@ -215,7 +215,7 @@ public partial class NDArray
 				            resArr[idx] = np1Array[idx] + scalar;
 				    }
 				    break;
-				}
+				}*/
                 default : 
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Operations/Elementwise/NdArray.Division.cs b/src/NumSharp.Core/Operations/Elementwise/NdArray.Division.cs
@@ -192,7 +192,7 @@ public partial class NDArray
 				    break;
 				}
 
-				case System.Numerics.Quaternion[] resArr : 
+				/*case System.Numerics.Quaternion[] resArr : 
 				{
 				    System.Numerics.Quaternion[] np1Array = np1SysArr as System.Numerics.Quaternion[];
 				    System.Numerics.Quaternion[] np2Array = np2SysArr as System.Numerics.Quaternion[];
@@ -215,7 +215,7 @@ public partial class NDArray
 				            resArr[idx] = np1Array[idx] / scalar;
 				    }
 				    break;
-				}
+				}*/
                 default : 
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Operations/Elementwise/NdArray.Multiplication.cs b/src/NumSharp.Core/Operations/Elementwise/NdArray.Multiplication.cs
@@ -191,7 +191,7 @@ public partial class NDArray
 				    break;
 				}
 
-				case System.Numerics.Quaternion[] resArr : 
+				/*case System.Numerics.Quaternion[] resArr : 
 				{
 				    System.Numerics.Quaternion[] np1Array = np1SysArr as System.Numerics.Quaternion[];
 				    System.Numerics.Quaternion[] np2Array = np2SysArr as System.Numerics.Quaternion[];
@@ -214,7 +214,7 @@ public partial class NDArray
 				            resArr[idx] = np1Array[idx] * scalar;
 				    }
 				    break;
-				}
+				}*/
                 default : 
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Operations/Elementwise/NdArray.Substraction.cs b/src/NumSharp.Core/Operations/Elementwise/NdArray.Substraction.cs
@@ -192,7 +192,7 @@ public partial class NDArray
 				    break;
 				}
 
-				case System.Numerics.Quaternion[] resArr : 
+				/*case System.Numerics.Quaternion[] resArr : 
 				{
 				    System.Numerics.Quaternion[] np1Array = np1SysArr as System.Numerics.Quaternion[];
 				    System.Numerics.Quaternion[] np2Array = np2SysArr as System.Numerics.Quaternion[];
@@ -215,7 +215,7 @@ public partial class NDArray
 				            resArr[idx] = np1Array[idx] - scalar;
 				    }
 				    break;
-				}
+				}*/
                 default : 
                 {
                     throw new IncorrectTypeException();
diff --git a/src/NumSharp.Core/Selection/NDArray.Indexing.cs b/src/NumSharp.Core/Selection/NDArray.Indexing.cs
@@ -31,63 +31,118 @@ public NDArray this[NDArray indexes]
         {
             get
             {
-                if(!(indexes.ndim == 1))
-                            throw new IncorrectShapeException();
-
-                Array indexesArr = indexes.Storage.GetData();
-                Array thisArr = this.Storage.GetData();
-                
                 NDArray selectedValues = null;
 
-                switch (this.ndim)
+                switch (ndim)
                 {
-                    case 1 :
-                    {
-                        selectedValues = new NDArray(this.dtype, indexes.size);
-
-                        Array selValArr = selectedValues.Storage.GetData();
-                    
-                        for(int idx = 0; idx < indexesArr.Length;idx++)
-                            selValArr.SetValue(thisArr.GetValue(Convert.ToInt32(indexesArr.GetValue(idx))),idx);
-                    
+                    case 1:
+                        if (dtype.Name == "Byte")
+                            selectedValues = setValue1D<byte>(indexes);
+                        if (dtype.Name == "Int32")
+                            selectedValues = setValue1D<int>(indexes);
+                        if (dtype.Name == "Single")
+                            selectedValues = setValue1D<float>(indexes);
+                        else if (dtype.Name == "Double")
+                            selectedValues = setValue1D<double>(indexes);
+                        break;
+                    case 2:
+                        if (dtype.Name == "Byte")
+                            selectedValues = setValue2D<byte>(indexes);
+                        if (dtype.Name == "Int32")
+                            selectedValues = setValue2D<int>(indexes);
+                        if (dtype.Name == "Single")
+                            selectedValues = setValue2D<float>(indexes);
+                        else if (dtype.Name == "Double")
+                            selectedValues = setValue2D<double>(indexes);
+                        break;
+                    case 3:
+                        if (dtype.Name == "Byte")
+                            selectedValues = setValue3D<byte>(indexes);
+                        if (dtype.Name == "Int32")
+                            selectedValues = setValue3D<int>(indexes);
+                        if (dtype.Name == "Single")
+                            selectedValues = setValue3D<float>(indexes);
+                        else if (dtype.Name == "Double")
+                            selectedValues = setValue3D<double>(indexes);
                         break;
-                    }
-                    case 2 :
-                    {
-                            var buf = Data<int>();
-                            selectedValues = new NDArray(this.dtype, new Shape(indexes.size, shape[1]));
-                            Parallel.ForEach(Enumerable.Range(0, selectedValues.shape[0]), (row) =>
-                            {
-                                for (int col = 0; col < selectedValues.shape[1]; col++)
-                                    selectedValues[row, col] = buf[Storage.Shape.GetIndexInShape(indexes.Data<int>(row), col)];
-                            });
-
-                            break;
-                    }
                     case 4:
-                    {
-                            int pos = -1;
-                            var buf = Data<int>();
-                            selectedValues = new NDArray(this.dtype, new Shape(indexes.size, shape[1], shape[2], shape[3]));
-
-                            Parallel.ForEach(Enumerable.Range(0, selectedValues.shape[0]), (item) =>
-                            {
-                                for (int row = 0; row < selectedValues.shape[1]; row++)
-                                    for (int col = 0; col < selectedValues.shape[2]; col++)
-                                        for (int channel = 0; channel < selectedValues.shape[3]; channel++)
-                                        {
-                                            pos = Storage.Shape.GetIndexInShape(indexes.Data<int>(item), row, col, channel);
-                                            selectedValues[item, row, col, channel] = buf[pos];
-                                        }
-                            });
-
-                            break;
-                    }
+                        if (dtype.Name == "Byte")
+                            selectedValues = setValue4D<byte>(indexes);
+                        if (dtype.Name == "Int32")
+                            selectedValues = setValue4D<int>(indexes);
+                        if (dtype.Name == "Single")
+                            selectedValues = setValue4D<float>(indexes);
+                        else if (dtype.Name == "Double")
+                            selectedValues = setValue4D<double>(indexes);
+                        break;
                 }
 
                 return selectedValues;
             }
         }
+
+        private NDArray setValue1D<T>(NDArray indexes)
+        {
+            var buf = Data<T>();
+            var idx = indexes.Data<int>();
+            var values = new T[indexes.size];
+
+            Parallel.ForEach(Enumerable.Range(0, indexes.size), (row) =>
+            {
+                values[row] = buf[idx[row]];
+            });
+
+            return new NDArray(values, indexes.size);
+        }
+
+        private NDArray setValue2D<T>(NDArray indexes)
+        {
+            var buf = Data<T>();
+            var idx = indexes.Data<int>();
+            var selectedValues = new NDArray(this.dtype, new Shape(indexes.size, shape[1]));
+
+            Parallel.ForEach(Enumerable.Range(0, selectedValues.shape[0]), (row) =>
+            {
+                for (int col = 0; col < selectedValues.shape[1]; col++)
+                    selectedValues[row, col] = buf[Storage.Shape.GetIndexInShape(idx[row], col)];
+            });
+
+            return selectedValues;
+        }
+
+        private NDArray setValue3D<T>(NDArray indexes)
+        {
+            var buf = Data<T>();
+            var selectedValues = new NDArray(this.dtype, new Shape(indexes.size, shape[1], shape[2]));
+            var idx = indexes.Data<int>();
+
+            Parallel.ForEach(Enumerable.Range(0, selectedValues.shape[0]), (item) =>
+            {
+                for (int row = 0; row < selectedValues.shape[1]; row++)
+                    for (int col = 0; col < selectedValues.shape[2]; col++)
+                            selectedValues[item, row, col] = buf[Storage.Shape.GetIndexInShape(idx[item], row, col)];
+            });
+
+            return selectedValues;
+        }
+
+        private NDArray setValue4D<T>(NDArray indexes)
+        {
+            var buf = Data<T>();
+            var selectedValues = new NDArray(this.dtype, new Shape(indexes.size, shape[1], shape[2], shape[3]));
+            var idx = indexes.Data<int>();
+
+            Parallel.ForEach(Enumerable.Range(0, selectedValues.shape[0]), (item) =>
+            {
+                for (int row = 0; row < selectedValues.shape[1]; row++)
+                    for (int col = 0; col < selectedValues.shape[2]; col++)
+                        for (int channel = 0; channel < selectedValues.shape[3]; channel++)
+                            selectedValues[item, row, col, channel] = buf[Storage.Shape.GetIndexInShape(idx[item], row, col, channel)];
+            });
+
+            return selectedValues;
+        }
+
         public NDArray this[NumSharp.Generic.NDArray<bool> booleanArray]
         {
             get
diff --git a/test/NumSharp.UnitTest/Creation/NdArray.Array.Test.cs b/test/NumSharp.UnitTest/Creation/NdArray.Array.Test.cs
diff --git a/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs b/test/NumSharp.UnitTest/Selection/NDArray.Indexing.Test.cs

Original file line number	Diff line number	Diff line change
`@@ -141,12 +141,12 @@ public static implicit operator NDArray(Complex d)`
`141`	`141`	`return ndArray;`
`142`	`142`	`}`
`143`	`143`
`144`		`- public static implicit operator NDArray(Quaternion d)`
	`144`	`+ /*public static implicit operator NDArray(Quaternion d)`
`145`	`145`	`{`
`146`	`146`	`var ndArray = new NDArray(typeof(Quaternion),new int[0]);`
`147`	`147`	`ndArray.Storage.SetData(new Quaternion[]{d});`
`148`	`148`
`149`	`149`	`return ndArray;`
`150`		`- }`
	`150`	`+ }*/`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,12 +53,12 @@ public NDArray arange(int stop, int start = 0, int step = 1)`
`53`	`53`	`dataArray = list.Select(x => (Complex)x).ToArray();`
`54`	`54`	`break;`
`55`	`55`	`}`
`56`		`- case Quaternion[] dataArray:`
	`56`	`+ /*case Quaternion[] dataArray:`
`57`	`57`	`{`
`58`	`58`	`// no performance critial operation`
`59`	`59`	`dataArray = list.Select(x => new Quaternion(new Vector3(0, 0, 0), x)).ToArray();`
`60`	`60`	`break;`
`61`		`- }`
	`61`	`+ }*/`
`62`	`62`	`default:`
`63`	`63`	`{`
`64`	`64`	`throw new IncorrectTypeException();`
Original file line number	Diff line number	Diff line change
`@@ -54,12 +54,12 @@ public NDArray linspace(double start, double stop,int num, bool entdpoint = true`
`54`	`54`	`dataArray[idx] = (Complex)doubleArray[idx];`
`55`	`55`	`break;`
`56`	`56`	`}`
`57`		`- case Quaternion[] dataArray :`
	`57`	`+ /*case Quaternion[] dataArray :`
`58`	`58`	`{`
`59`	`59`	`for(int idx = 0; idx < dataArray.Length;idx++)`
`60`	`60`	`dataArray[idx] = new Quaternion(new Vector3(0,0,0),(float)doubleArray[idx]);`
`61`	`61`	`break;`
`62`		`- }`
	`62`	`+ }*/`
`63`	`63`	`default :`
`64`	`64`	`{`
`65`	`65`	`throw new IncorrectTypeException();`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public static NDArray array(Array array, Type dtype = null, int ndim = 1)`
`30`	`30`	`return nd;`
`31`	`31`	`}`
`32`	`32`
`33`		`- public static NDArray array(System.Drawing.Bitmap image)`
	`33`	`+ /*public static NDArray array(System.Drawing.Bitmap image)`
`34`	`34`	`{`
`35`	`35`	`var imageArray = new NDArray(typeof(Byte));`
`36`	`36`
`@@ -45,7 +45,7 @@ public static NDArray array(System.Drawing.Bitmap image)`
`45`	`45`	`imageArray.Storage.SetData(bytes);`
`46`	`46`
`47`	`47`	`return imageArray;`
`48`		`- }`
	`48`	`+ }*/`
`49`	`49`
`50`	`50`	`public static NDArray array<T>(T[][] data)`
`51`	`51`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ public static partial class np`
`9`	`9`	`public static NDArray prod(NDArray nd, int axis = -1, Type dtype = null)`
`10`	`10`	`{`
`11`	`11`	`NDArray result = null;`
	`12`	`+ if (nd.size == 0) return 1;`
	`13`	`+`
`12`	`14`	`if(axis == -1)`
`13`	`15`	`{`
`14`	`16`	`switch (nd.dtype.Name)`
Original file line number	Diff line number	Diff line change
`@@ -144,13 +144,13 @@ protected Array _ChangeTypeOfArray(Array arrayVar, Type dtype)`
`144`	`144`	`newValues.SetValue(new System.Numerics.Complex((double)arrayVar.GetValue(idx),0),idx);`
`145`	`145`	`break;`
`146`	`146`	`}`
`147`		`- else if ( dtype == typeof(System.Numerics.Quaternion) )`
	`147`	`+ /*else if ( dtype == typeof(System.Numerics.Quaternion) )`
`148`	`148`	`{`
`149`	`149`	`newValues = new System.Numerics.Quaternion[arrayVar.Length];`
`150`	`150`	`for(int idx = 0;idx < arrayVar.Length;idx++)`
`151`	`151`	`newValues.SetValue(new System.Numerics.Quaternion(new System.Numerics.Vector3(0,0,0) , (float)arrayVar.GetValue(idx)),idx);`
`152`	`152`	`break;`
`153`		`- }`
	`153`	`+ }*/`
`154`	`154`	`else`
`155`	`155`	`{`
`156`	`156`	`newValues = new object[arrayVar.Length];`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ public partial class NDArray`
`64`	`64`	`}`
`65`	`65`	`break;`
`66`	`66`	`}`
`67`		`- case Quaternion[] values :`
	`67`	`+ /*case Quaternion[] values :`
`68`	`68`	`{`
`69`	`69`	`Quaternion value = (Quaternion) obj;`
`70`	`70`	`for(int idx =0; idx < bools.Length;idx++)`
`@@ -73,7 +73,7 @@ public partial class NDArray`
`73`	`73`	`bools[idx] = true;`
`74`	`74`	`}`
`75`	`75`	`break;`
`76`		`- }`
	`76`	`+ }*/`
`77`	`77`	`default :`
`78`	`78`	`{`
`79`	`79`	`throw new IncorrectTypeException();`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ public partial class NDArray`
`192`	`192`	`break;`
`193`	`193`	`}`
`194`	`194`
`195`		`- case System.Numerics.Quaternion[] resArr :`
	`195`	`+ /*case System.Numerics.Quaternion[] resArr :`
`196`	`196`	`{`
`197`	`197`	`System.Numerics.Quaternion[] np1Array = np1SysArr as System.Numerics.Quaternion[];`
`198`	`198`	`System.Numerics.Quaternion[] np2Array = np2SysArr as System.Numerics.Quaternion[];`
`@@ -215,7 +215,7 @@ public partial class NDArray`
`215`	`215`	`resArr[idx] = np1Array[idx] + scalar;`
`216`	`216`	`}`
`217`	`217`	`break;`
`218`		`- }`
	`218`	`+ }*/`
`219`	`219`	`default :`
`220`	`220`	`{`
`221`	`221`	`throw new IncorrectTypeException();`