/// <summary> /// Filter specific elements through select. /// </summary> /// <param name="select"></param> /// <returns>Return a new NDArray with filterd elements.</returns> public NDArrayGeneric <T> this[IList <int> select] { get { var n = new NDArrayGeneric <T>(); if (NDim == 1) { n.Data = new T[select.Count]; n.Shape = new Shape(select.Count); for (int i = 0; i < select.Count; i++) { n[i] = this[select[i]]; } } else if (NDim == 2) { n.Data = new T[select.Count * Shape[1]]; n.Shape = new Shape(select.Count, Shape[1]); for (int i = 0; i < select.Count; i++) { for (int j = 0; j < Shape[1]; j++) { n[i, j] = this[select[i], j]; } } } else { throw new NotImplementedException(); } return(n); } }
public NDArrayGeneric <T> this[Shape select] { get { if (select.NDim == NDim) { throw new Exception("Please use NDArray[m, n] to access element."); } else { int start = GetIndexInShape(select.Shapes.ToArray()); int length = Shape.DimOffset[select.NDim - 1]; var n = new NDArrayGeneric <T>(); Span <T> data = Data; n.Data = data.Slice(start, length).ToArray(); int[] shape = new int[Shape.NDim - select.NDim]; for (int i = select.NDim; i < Shape.NDim; i++) { shape[i - select.NDim] = Shape[i]; } n.Shape = new Shape(shape); // n.Shape = new Shape(Shape.Shapes.ToArray().AsSpan().Slice(select.Length).ToArray()); return(n); } } }
public NDArrayGeneric <T> arange(int start, int stop, int step = 1) { if (start > stop) { throw new Exception("parameters invalid"); } switch (typeof(T).Name) { case "Int32": { var n = new NDArrayGeneric <int>(); n.arange(stop, start, step); return(n as NDArrayGeneric <T>); } case "Double": { var n = new NDArrayGeneric <double>(); n.arange(stop, start, step); return(n as NDArrayGeneric <T>); } default: throw new NotImplementedException(); } }
public static dynamic arange(object start, object stop, object step) { dynamic returnValue = null; switch (start) { case int startCast: { int stopCast = (int)stop; int stepCast = (int)step; returnValue = new NumSharp.Core.NDArrayGeneric <int>().arange(stopCast, startCast, stepCast); break; } case float startCast_: { int startCast = (int)start; int stopCast = (int)stop; int stepCast = (int)step; returnValue = new NumSharp.Core.NDArrayGeneric <float>().arange(stopCast, startCast, stepCast); break; } } return(returnValue); }
public static NDArrayGeneric <T> sin <T>(this NumPyGeneric <T> np, NDArrayGeneric <T> nd) { NDArrayGeneric <T> sinArray = new NDArrayGeneric <T>(); sinArray.Data = new T[nd.Size]; sinArray.Shape = new Shape(nd.Shape.Shapes); for (int idx = 0; idx < nd.Size; idx++) { switch (nd[idx]) { case double d: sinArray[idx] = (T)(object)Math.Sin(d); break; case float d: sinArray[idx] = (T)(object)Math.Sin(d); break; case Complex d: sinArray[idx] = (T)(object)Complex.Sin(d); break; } } return(sinArray); }
/// <summary> /// Stack arrays in sequence vertically (row wise). /// </summary> /// <param name="nps"></param> /// <returns></returns> public static NDArrayGeneric <T> VStack <T>(this NDArrayGeneric <T> np1, params NDArrayGeneric <T>[] nps) { if (nps == null || nps.Length == 0) { throw new Exception("Input arrays can not be empty"); } List <T> list = new List <T>(); NDArrayGeneric <T> np = new NDArrayGeneric <T>(); foreach (NDArrayGeneric <T> ele in nps) { if (nps[0].Shape != ele.Shape) { throw new Exception("Arrays mush have same shapes"); } list.AddRange(ele.Data); } np.Data = list.ToArray(); if (nps[0].NDim == 1) { np.Shape = new Shape(new int[] { nps.Length, nps[0].Shape.Shapes[0] }); } else { int[] shapes = nps[0].Shape.Shapes.ToArray(); shapes[0] *= nps.Length; np.Shape = new Shape(shapes); } return(np); }
public NDArrayGeneric <T> power(T exponent) { NDArrayGeneric <T> sinArray = new NDArrayGeneric <T>(); sinArray.Data = new T[this.Size]; sinArray.Shape = new Shape(this.Shape.Shapes); switch (Data) { case double[] sinData: { for (int idx = 0; idx < sinData.Length; idx++) { sinArray[idx] = (T)(object)Math.Pow(sinData[idx], (double)(object)exponent); } break; } default: { throw new Exception("The operation is not implemented for the"); } } return(sinArray); }
public NDArrayGeneric <T> inv() { NDArrayGeneric <T> npInv = new NDArrayGeneric <T>(); npInv.Shape = new Shape(this.Shape.Shapes); npInv.Data = new T[this.Data.Length]; switch (this) { case NDArrayGeneric <double> np: { NDArrayGeneric <double> npInvDouble = npInv as NDArrayGeneric <double>; double[][] matrix = np.ToDotNetArray <double[][]>(); double[][] matrixInv = MatrixInv.InverseMatrix(matrix); for (int idx = 0; idx < npInv.Shape.Shapes[0]; idx++) { for (int jdx = 0; jdx < npInv.Shape.Shapes[1]; jdx++) { npInvDouble[idx, jdx] = matrixInv[idx][jdx]; } } break; } default: { throw new Exception("This method was not implemented for this Type : " + typeof(T).Name); } } return(npInv); }
public static NDArrayGeneric <T> array <T>(this NumPyGeneric <T> np, IEnumerable <T> array, int ndim = 1) { var nd = new NDArrayGeneric <T>(); nd.Data = array.ToArray(); nd.Shape = new Shape(new int[] { nd.Data.Length }); return(nd); }
public NDArrayGeneric <T> array(T[] data) { var n = new NDArrayGeneric <T>(); n.Data = data; n.Shape = new Shape(new int[] { data.Length }); return(n); }
public NDArrayGeneric <T> log() { NDArrayGeneric <T> logArray = new NDArrayGeneric <T>(); logArray.Data = new T[this.Data.Length]; logArray.Shape = new Shape(this.Shape.Shapes); switch (logArray.Data) { case double[] logData: { double[] npData = this.Data as double[]; for (int idx = 0; idx < npData.Length; idx++) { logData[idx] = Math.Log(npData[idx]); } break; } case float[] logData: { double[] npData = this.Data as double[]; for (int idx = 0; idx < npData.Length; idx++) { // boxing necessary because Math.Sin just for double logData[idx] = (float)Math.Log(npData[idx]); } break; } case Complex[] logData: { Complex[] npData = this.Data as Complex[]; for (int idx = 0; idx < npData.Length; idx++) { // boxing necessary because Math.Sin just for double logData[idx] = Complex.Log(npData[idx]); } break; } default: { throw new Exception("The operation is not implemented for the"); } } return(logArray); }
public static NDArrayGeneric <Byte> array <T>(this NumPyGeneric <T> np, System.Drawing.Bitmap image) { NDArrayGeneric <Byte> imageArray = new NDArrayGeneric <Byte>(); var bmpd = image.LockBits(new System.Drawing.Rectangle(0, 0, image.Width, image.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, image.PixelFormat); var dataSize = bmpd.Stride * bmpd.Height; imageArray.Data = new byte[dataSize]; System.Runtime.InteropServices.Marshal.Copy(bmpd.Scan0, imageArray.Data, 0, imageArray.Data.Length); image.UnlockBits(bmpd); imageArray.Shape = new Shape(new int[] { bmpd.Height, bmpd.Width, System.Drawing.Image.GetPixelFormatSize(image.PixelFormat) / 8 }); return(imageArray); }
/// <summary> /// Return a new array of given shape and type, filled with ones. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="np"></param> /// <param name="shape"></param> /// <returns></returns> public static NDArrayGeneric <T> ones <T>(this NumPyGeneric <T> np, Shape shape) { var nd = new NDArrayGeneric <T>(); nd.Shape = shape; switch (default(T)) { case int data: nd.Data = Enumerable.Range(0, nd.Size).Select(x => (T)(object)1).ToArray(); break; case double data: nd.Data = Enumerable.Range(0, nd.Size).Select(x => (T)(object)1.0).ToArray(); break; } return(nd); }
public NDArrayGeneric <T> zeros(params int[] shape) { switch (typeof(T).Name) { case "Int32": { var n = new NDArrayGeneric <int>(); n.Zeros(shape); return(n as NDArrayGeneric <T>); } case "Double": { var n = new NDArrayGeneric <double>(); n.Zeros(shape); return(n as NDArrayGeneric <T>); } default: throw new NotImplementedException(); } }
public NDArrayGeneric <T> array(T[][] data) { int size = data.Length * data[0].Length; var all = new T[size]; int idx = 0; for (int row = 0; row < data.Length; row++) { for (int col = 0; col < data[row].Length; col++) { all[idx] = data[row][col]; idx++; } } var n = new NDArrayGeneric <T>(); n.Data = all; n.Shape = new Shape(new int[] { data.Length, data[0].Length }); return(n); }
public static NDArrayGeneric <NDArrayGeneric <T> > sin <T>(this NumPyGeneric <T> np, NDArrayGeneric <NDArrayGeneric <T> > nd) { var sinArray = new NDArrayGeneric <NDArrayGeneric <T> >(); sinArray.Data = new NDArrayGeneric <T> [nd.Size]; sinArray.Shape = new Shape(nd.Shape.Shapes); for (int idx = 0; idx < nd.Size; idx++) { switch (default(T)) { case double d: sinArray[idx] = new NDArrayGeneric <T> { Data = new T[] { (T)(object)Math.Sin(d) }, Shape = new Shape(1) }; break; } } return(sinArray); }
/// <summary> /// Draw random samples from a normal (Gaussian) distribution. /// </summary> /// <param name="loc">Mean of the distribution</param> /// <param name="scale">Standard deviation of the distribution</param> /// <param name="size"></param> /// <returns></returns> public NDArrayGeneric <double> normal(double loc, double scale, params int[] size) { if (size.Length == 0) { throw new Exception("d cannot be empty."); } NDArrayGeneric <double> array = new NDArrayGeneric <double>(); Random rand = new Random(); //reuse this if you are generating many array.Shape = new Shape(size); array.Data = new double[array.Shape.Size]; for (int i = 0; i < array.Shape.Size; i++) { double u1 = 1.0 - rand.NextDouble(); //uniform(0,1] random doubles double u2 = 1.0 - rand.NextDouble(); double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2); //random normal(0,1) double randNormal = loc + scale * randStdNormal; //random normal(mean,stdDev^2) array.Data[i] = randNormal; } return(array); }
public NDArrayGeneric <NDArrayGeneric <T> > this[Slice select] { get { var result = new NDArrayGeneric <NDArrayGeneric <T> >(); result.Data = new NDArrayGeneric <T> [select.Length]; result.shape = new Shape(select.Length); 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]; } } int index = 0; var list = new NDArrayGeneric <T>(); for (int s = select.Start; s < select.Stop; s += select.Step) { var n = new NDArrayGeneric <T>(); Span <T> data = Data; n.Data = data.Slice(s, select.Step).ToArray(); n.Shape = new Shape(shape); result.Data[index] = n; index++; } return(result); } }
public NDArrayGeneric <T> transpose() { var np = new NDArrayGeneric <T>(); np.Data = new T[this.Data.Length]; if (NDim == 1) { np.Shape = new Shape(1, Shape.Shapes[0]); } else { np.Shape = new Shape(this.Shape.Shapes.Reverse().ToArray()); for (int idx = 0; idx < np.shape.Shapes[0]; idx++) { for (int jdx = 0; jdx < np.shape.Shapes[1]; jdx++) { np[idx, jdx] = this[jdx, idx]; } } } return(np); }
public NDArrayGeneric <double> amin(NDArrayGeneric <double> np, int?axis = null) { return(np.AMin(axis)); }
/// <summary> /// Overload /// </summary> /// <param name="select"></param> /// <returns></returns> public NDArrayGeneric <T> this[NDArrayGeneric <int> select] => this[select.Data.ToList()];
public NDArrayGeneric <double> max(NDArrayGeneric <double> nd) { return(nd.Max()); }
public NDArrayGeneric <double> power(NDArrayGeneric <double> nd, double exponent) { return(nd.power(exponent)); }
public NDArrayGeneric <double> absolute(NDArrayGeneric <double> np) { return(np.Absolute()); }
/// <summary> /// /// </summary> /// <param name="np1"></param> /// <param name="np2"></param> /// <typeparam name="TData"></typeparam> /// <returns></returns> public NDArrayGeneric <T> dot(NDArrayGeneric <T> np2) { if ((this.Shape.Length == 1) & (np2.Shape.Length == 1)) { if (this.Shape.Shapes[0] != np2.Shape.Shapes[0]) { throw new Exception("The Dot method does not work with this shape or was not already implemented."); } else { np2.Shape = new Shape(np2.Data.Length, 1); this.Shape = new Shape(1, this.Data.Length); } } else if (this.Shape.Shapes[1] != np2.Shape.Shapes[0]) { throw new Exception("The Dot method does not work with this shape or was not already implemented."); } int iterator = this.Shape.Shapes[1]; int dim0 = this.Shape.Shapes[0]; int dim1 = np2.Shape.Shapes[1]; NDArrayGeneric <T> prod = new NDArrayGeneric <T>(); prod.Shape = new Shape(dim0, dim1); prod.Data = new T[prod.Shape.Size]; switch (this.Data) { case double[] np1Array: { double[] result = prod.Data as double[]; double[] np2Array = np2.Data as double[]; for (int idx = 0; idx < prod.Data.Length; idx++) { int puffer1 = idx / dim1; int puffer2 = idx % dim1; int puffer3 = puffer1 * iterator; for (int kdx = 0; kdx < iterator; kdx++) { result[idx] += np1Array[puffer3 + kdx] * np2Array[dim1 * kdx + puffer2]; } } break; } case float[] np1Array: { float[] result = prod.Data as float[]; float[] np2Array = np2.Data as float[]; for (int idx = 0; idx < prod.Data.Length; idx++) { int puffer1 = idx / dim1; int puffer2 = idx % dim1; int puffer3 = puffer1 * iterator; for (int kdx = 0; kdx < iterator; kdx++) { result[idx] += np1Array[puffer3 + kdx] * np2Array[dim1 * kdx + puffer2]; } } break; } case Complex[] np1Array: { Complex[] result = prod.Data as Complex[]; Complex[] np2Array = np2.Data as Complex[]; for (int idx = 0; idx < prod.Data.Length; idx++) { int puffer1 = idx / dim1; int puffer2 = idx % dim1; int puffer3 = puffer1 * iterator; for (int kdx = 0; kdx < iterator; kdx++) { result[idx] += np1Array[puffer3 + kdx] * np2Array[dim1 * kdx + puffer2]; } } break; } case Quaternion[] np1Array: { Quaternion[] result = prod.Data as Quaternion[]; Quaternion[] np2Array = np2.Data as Quaternion[]; for (int idx = 0; idx < prod.Data.Length; idx++) { int puffer1 = idx / dim1; int puffer2 = idx % dim1; int puffer3 = puffer1 * iterator; for (int kdx = 0; kdx < iterator; kdx++) { result[idx] += np1Array[puffer3 + kdx] * np2Array[dim1 * kdx + puffer2]; } } break; } default: { throw new Exception("The Dot method is not implemented for the " + typeof(T).Name); } } if ((this.Shape.Length == 1) & (np2.Shape.Length == 1)) { this.Shape = new Shape(this.Data.Length); np2.Shape = new Shape(np2.Data.Length); prod.Shape = new Shape(1); } return(prod); }
public NDArrayGeneric <double> hstack(params NDArrayGeneric <double>[] nps) { var n = new NDArrayGeneric <double>(); return(n.HStack(nps)); }
public NDArrayGeneric <int> reshape(NDArrayGeneric <int> np, params int[] shape) { np.Shape = new Shape(shape); return(np); }
public static NDArrayGeneric <T> operator +(NDArrayGeneric <T> np1, T scalar) { NDArrayGeneric <T> sum = new NDArrayGeneric <T>(); sum.Shape = np1.Shape; sum.Data = new T[np1.Data.Length]; switch (scalar) { case double scalarDouble: { double[] np1Array = np1.Data as double[]; double[] sumArray = sum.Data as double[]; // for is faster than linq for (int idx = 0; idx < sumArray.Length; idx++) { sumArray[idx] = np1Array[idx] + scalarDouble; } break; } case float scalarFloat: { float[] np1Array = np1.Data as float[]; float[] sumArray = sum.Data as float[]; // for is faster than linq for (int idx = 0; idx < sumArray.Length; idx++) { sumArray[idx] = np1Array[idx] + scalarFloat; } break; } case Complex scalarComplex: { Complex[] np1Array = np1.Data as Complex[]; Complex[] sumArray = sum.Data as Complex[]; // for is faster than linq for (int idx = 0; idx < sumArray.Length; idx++) { sumArray[idx] = np1Array[idx] + scalarComplex; } break; } case Quaternion scalarQuaternion: { Quaternion[] np1Array = np1.Data as Quaternion[]; Quaternion[] sumArray = sum.Data as Quaternion[]; // for is faster than linq for (int idx = 0; idx < sumArray.Length; idx++) { sumArray[idx] = np1Array[idx] + scalarQuaternion; } break; } default: { throw new Exception("The operation is not implemented for the " + typeof(T).Name); } } return((NDArrayGeneric <T>)sum); }
public static NDArrayGeneric <T> ones_like <T>(this NumPyGeneric <T> np, NDArrayGeneric <T> nd, string order = "C") { return(np.ones(new Shape(nd.Shape.Shapes))); }