public static NDArray_Legacy <NDArray_Legacy <double> > Minus(this NDArray_Legacy <NDArray_Legacy <double> > np, double minus) { return(new NDArray_Legacy <NDArray_Legacy <double> > { Data = np.Data.Select(row => new NDArray_Legacy <double> { Data = row.Data.Select(col => col - minus).ToList() }).ToList() }); }
public static NDArray_Legacy <NDArray_Legacy <double> > Divide(this NDArray_Legacy <NDArray_Legacy <double> > np, double divisor) { return(new NDArray_Legacy <NDArray_Legacy <double> > { Data = np.Data.Select(row => new NDArray_Legacy <double> { Data = row.Data.Select(col => col / divisor).ToList() }).ToList() }); }
public static void Shuffle(this NDArrayRandom rand, NDArray_Legacy <NDArray_Legacy <double> > list) { var rng = new Random(); var count = list.Length; while (count > 1) { count--; var k = rng.Next(count + 1); var value = list[k]; list[k] = list[count]; list[count] = value; } }
public void ConvoleSame() { var series1 = new NDArray_Legacy <double>(); series1.Data = new double[] { 1, 2, 3 }; var series2 = new NDArray_Legacy <double>(); series2.Data = new double[] { 0, 1, 0.5 }; var series3 = series1.Convolve(series2, "same"); double[] expectedResult = new double[] { 1, 2.5, 4 }; Assert.IsTrue(Enumerable.SequenceEqual(series3.Data.ToArray(), expectedResult)); }
public static NDArray_Legacy <double> Std(this NDArray_Legacy <NDArray_Legacy <double> > np, int axis = -1) { var std = new NDArray_Legacy <double>(); var mean = np.Mean(axis); // axis == -1: DEFAULT; to compute the standard deviation of the flattened array. if (axis == -1) { var sum = np.Data.Select(d => d.Data.Select(p => Math.Pow(Math.Abs(p - mean.Data[0]), 2)).Sum()).Sum(); std.Data.Add(Math.Sqrt(sum / np.Size)); } // to compute mean by compressing row and row else if (axis == 0) { double[] sumVec = new double[np.Data[0].Length]; for (int d = 0; d < np.Length; d++) { for (int p = 0; p < np.Data[0].Length; p++) { sumVec[p] += np.Data[d][p]; } } for (int d = 0; d < np.Data[0].Length; d++) { mean.Data.Add(sumVec[d] / np.Length); } } else if (axis == 1) { for (int d = 0; d < np.Length; d++) { double rowSum = 0; for (int p = 0; p < np.Data[0].Length; p++) { rowSum += np.Data[d][p]; } mean.Data.Add(rowSum / np.Data[0].Length); } } return(std); }
public void Mean() { var series1 = new NDArray_Legacy <double>(); series1.Data = new double[] { 1, 2 }; var series2 = new NDArray_Legacy <double>(); series2.Data = new double[] { 3, 4 }; var np = new NDArray_Legacy <NDArray_Legacy <double> >(); np.Data.Add(series1); np.Data.Add(series2); //Assert.IsTrue(Enumerable.SequenceEqual(np.Mean().Data, new double[] { 2.5 })); Assert.IsTrue(Enumerable.SequenceEqual(np.Mean(0).Data, new double[] { 2, 3 })); Assert.IsTrue(Enumerable.SequenceEqual(np.Mean(1).Data, new double[] { 1.5, 3.5 })); }
public void StdTest() { var series1 = new NDArray <double>(); series1.Data = new double[] { 1, 2 }; var series2 = new NDArray <double>(); series2.Data = new double[] { 3, 4 }; var np = new NDArray_Legacy <NDArray <double> >(); np.Data.Add(series1); np.Data.Add(series2); // Assert.IsTrue(Enumerable.SequenceEqual(np.Std().Data, new double[] { 1.1180339887498949 })); // Assert.IsTrue(Enumerable.SequenceEqual(np.Std(0).Data, new double[] { 1, 1 })); // Assert.IsTrue(Enumerable.SequenceEqual(np.Std(1).Data, new double[] { 0.5, 3.5 })); }
public static NDArray_Legacy <double> Mean(this NDArray_Legacy <NDArray_Legacy <double> > np, int axis = -1) { var mean = new NDArray_Legacy <double>(); // axis == -1: DEFAULT; to compute the mean of the flattened array. if (axis == -1) { var sum = np.Data.Select(d => d.Data.Sum()).Sum(); mean.Data.Add(sum / np.Size); } // to compute mean by compressing row and row else if (axis == 0) { double[] sumVec = new double[np.Data[0].Length]; for (int d = 0; d < np.Length; d++) { for (int p = 0; p < np.Data[0].Length; p++) { sumVec[p] += np.Data[d][p]; } } for (int d = 0; d < np.Data[0].Length; d++) { mean.Data.Add(sumVec[d] / np.Length); } } else if (axis == 1) { for (int d = 0; d < np.Length; d++) { double rowSum = 0; for (int p = 0; p < np.Data[0].Length; p++) { rowSum += np.Data[d][p]; } mean.Data.Add(rowSum / np.Data[0].Length); } } return(mean); }
public static Matrix <double> AsMatrix(this NDArray_Legacy <NDArray_Legacy <double> > np) { Matrix <double> npAsMatrix = new Matrix <double>(); int dim0 = np.Length; int dim1 = np.Data[0].Length; npAsMatrix.Shape = new List <int>() { dim0, dim1 }.ToList(); npAsMatrix.Data = new double[dim0 * dim1]; for (int idx = 0; idx < dim0; idx++) { for (int jdx = 0; jdx < dim1; jdx++) { npAsMatrix[idx, jdx] = np[idx][jdx]; } } return(npAsMatrix); }
/// <summary> /// Convolution of 2 series /// </summary> /// <param name="numSharpArray1"></param> /// <param name="numSharpArray2"></param> /// <param name="mode"></param> /// <returns></returns> public static NDArray_Legacy <double> Convolve(this NDArray_Legacy <double> numSharpArray1, NDArray_Legacy <double> numSharpArray2, string mode = "full") { int nf = numSharpArray1.Length; int ng = numSharpArray2.Length; var numSharpReturn = new NDArray_Legacy <double>(); switch (mode) { case "full": { int n = nf + ng - 1; var outArray = new double[n]; for (int idx = 0; idx < n; ++idx) { int jmn = (idx >= ng - 1) ? (idx - (ng - 1)) : 0; int jmx = (idx < nf - 1) ? idx : nf - 1; for (int jdx = jmn; jdx <= jmx; ++jdx) { outArray[idx] += (numSharpArray1[jdx] * numSharpArray2[idx - jdx]); } } numSharpReturn.Data = outArray; break; } case "valid": { var min_v = (nf < ng) ? numSharpArray1 : numSharpArray2; var max_v = (nf < ng) ? numSharpArray2 : numSharpArray1; int n = Math.Max(nf, ng) - Math.Min(nf, ng) + 1; double[] outArray = new double[n]; for (int idx = 0; idx < n; ++idx) { int kdx = idx; for (int jdx = (min_v.Length - 1); jdx >= 0; --jdx) { outArray[idx] += min_v[jdx] * max_v[kdx]; ++kdx; } } numSharpReturn.Data = outArray; break; } case "same": { // followed the discussion on // https://stackoverflow.com/questions/38194270/matlab-convolution-same-to-numpy-convolve // implemented numpy convolve because we follow numpy var npad = numSharpArray2.Length - 1; if (npad % 2 == 1) { npad = (int)Math.Floor(((double)npad) / 2.0); numSharpArray1.Data.ToList().AddRange(new double[npad + 1]); var puffer = (new double[npad]).ToList(); puffer.AddRange(numSharpArray1.Data); numSharpArray1.Data = puffer; } else { npad = npad / 2; var puffer = ((double[])numSharpArray1.Data).ToList(); puffer.AddRange(new double[npad]); numSharpArray1.Data = puffer; puffer = (new double[npad]).ToList(); puffer.AddRange(numSharpArray1.Data); numSharpArray1.Data = puffer; } numSharpReturn = numSharpArray1.Convolve(numSharpArray2, "valid"); break; } } return(numSharpReturn); }