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);
}
