public void TestFindBestNMotifsMultipleProfiles() { float[,] tss = { { 10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9 }, { 10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9 } }; float[,] tss2 = { { 10, 11, 10, 9 }, { 10, 11, 10, 9 } }; using (KhivaArray arr = KhivaArray.Create(tss), arr2 = KhivaArray.Create(tss2)) { var(pArr, iArr) = Matrix.Stomp(arr, arr2, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNMotifs(pArr, iArr, 3, 1); using (distancesArr) using (indicesArr) using (subsequenceArr) { var indices = indicesArr.GetData3D <uint>(); var subsequence = subsequenceArr.GetData3D <uint>(); Assert.AreEqual(new uint[, , ] { { { 12 }, { 12 } }, { { 12 }, { 12 } } }, indices); Assert.AreEqual(new uint[, , ] { { { 1 }, { 1 } }, { { 1 }, { 1 } } }, subsequence); } } } }
public void TestAggregatedLinearTrendMean() { var tss = new float[] { 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5 }; using (var arr = KhivaArray.Create(tss)) { var(slopeArr, interceptArr, rvalueArr, pValueArr, stderrestArr) = Features.AggregatedLinearTrend(arr, 3, 0); using (slopeArr) using (interceptArr) using (rvalueArr) using (pValueArr) using (stderrestArr) { var slope = slopeArr.GetData1D <float>(); var intercept = interceptArr.GetData1D <float>(); var rvalue = rvalueArr.GetData1D <float>(); var pvalue = pValueArr.GetData1D <float>(); var stderrest = stderrestArr.GetData1D <float>(); Assert.AreEqual(1, slope[0], Delta); Assert.AreEqual(2, intercept[0], Delta); Assert.AreEqual(1, rvalue[0], Delta); Assert.AreEqual(0, pvalue[0], Delta); Assert.AreEqual(0, stderrest[0], Delta); } } }
public void TestQuantileCut3() { float[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10, 11 } }; using (var arr = KhivaArray.Create(tss)) { var quantile = Statistics.QuantilesCutStatistics(arr, 3); float[,,] expected = { { { -0.0000F, -0.0000F, 1.6667F, 1.6667F, 3.3333F, 3.3333F }, { 1.6667F, 1.6667F, 3.3333F, 3.3333F, 5.0000F, 5.0000F } }, { { 6.0000F, 6.0000F, 7.6667F, 7.6667F, 9.3333F, 9.3333F }, { 7.6667F, 7.6667F, 9.3333F, 9.3333F, 11.0000F, 11.0000F } } }; using (quantile) { var result = quantile.GetData3D <float>(); Check3DArray(expected, result); } } }
public void TestFftCoefficient() { double[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10, 11 } }; using (var arr = KhivaArray.Create(tss)) { var(realArr, imagArr, absoluteArr, angleArr) = Features.FftCoefficient(arr, 0); using (realArr) using (imagArr) using (absoluteArr) using (angleArr) { var real = realArr.GetData2D <double>(); var imag = imagArr.GetData2D <double>(); var absolute = absoluteArr.GetData2D <double>(); var angle = angleArr.GetData2D <double>(); Assert.AreEqual(15, real[0, 0], Delta); Assert.AreEqual(51, real[1, 0], Delta); Assert.AreEqual(0, imag[0, 0], Delta); Assert.AreEqual(0, imag[1, 0], Delta); Assert.AreEqual(15, absolute[0, 0], Delta); Assert.AreEqual(51, absolute[1, 0], Delta); Assert.AreEqual(0, angle[0, 0], Delta); Assert.AreEqual(0, angle[1, 0], Delta); } } }
public void TestQuantileCut7() { float[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10, 11 } }; using (var arr = KhivaArray.Create(tss)) { var quantile = Statistics.QuantilesCutStatistics(arr, 7); float[,,] expected = { { { -0.0000F, 0.7143F, 1.4286F, 2.8571F, 3.5714F, 4.2857F }, { 0.7143F, 1.4286F, 2.1429F, 3.5714F, 4.2857F, 5.0000F } }, { { 6.0000F, 6.7143F, 7.4286F, 8.8571F, 9.5714F, 10.2857F }, { 6.7143F, 7.4286F, 8.1429F, 9.5714F, 10.2857F, 11.0000F } } }; using (quantile) { var result = quantile.GetData3D <float>(); Check3DArray(expected, result); } } }
public void TestCrossCovariance() { var tss = new float[, ] { { 0, 1, 2, 3 }, { 10, 11, 12, 13 } }; var tss2 = new float[, ] { { 4, 6, 8, 10, 12 }, { 14, 16, 18, 20, 22 } }; using (KhivaArray xss = KhivaArray.Create(tss), yss = KhivaArray.Create(tss2), approximateEntropy = Features.CrossCovariance(xss, yss, false)) { var result = approximateEntropy.GetData3D <float>(); var flatten = new float[result.Length]; Flatten3D(ref flatten, result); for (var i = 0; i < 4; i++) { Assert.AreEqual(2.5, flatten[i * 5], Delta); Assert.AreEqual(2.5, flatten[i * 5 + 1], Delta); Assert.AreEqual(0.25, flatten[i * 5 + 2], Delta); Assert.AreEqual(-1.25, flatten[i * 5 + 3], Delta); Assert.AreEqual(-1.5, flatten[i * 5 + 4], Delta); } } }
public void TestFriedrichCoefficients() { double[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 0, 1, 2, 3, 4, 5 } }; using (KhivaArray arr = KhivaArray.Create(tss), friedrichCoeff = Features.FriedrichCoefficients(arr, 4, 2)) { var result = friedrichCoeff.GetData2D <double>(); double[,] expected = { { -0.0009912563255056738, -0.0027067768387496471, -0.00015192681166809052, 0.10512571036815643, 0.89872437715530396 }, { -0.0009912563255056738, -0.0027067768387496471, -0.00015192681166809052, 0.10512571036815643, 0.89872437715530396 } }; for (var i = 0; i < result.GetLength(0); i++) { for (var j = 0; j < result.GetLength(1); j++) { Assert.AreEqual(expected[i, j], result[i, j], Delta); } } } }
public void TestFindBestNMotifsMirror() { float[] tss = { 10.1F, 11, 10.2F, 10.15F, 10.775F, 10.1F, 11, 10.2F }; using (var arr = KhivaArray.Create(tss)) { var(pArr, iArr) = Matrix.StompSelfJoin(arr, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNMotifs(pArr, iArr, 3, 2, true); using (distancesArr) using (indicesArr) using (subsequenceArr) { var indices = indicesArr.GetData2D <uint>(); var subsequence = subsequenceArr.GetData2D <uint>(); Assert.AreEqual(new uint[, ] { { 0, 0 } }, indices); Assert.AreEqual(new uint[, ] { { 5, 3 } }, subsequence); } } } }
public void TestStompSelfJoin() { float[,] tss = { { 10, 10, 11, 11, 10, 11, 10, 10, 11, 11, 10, 11, 10, 10 }, { 11, 10, 10, 11, 10, 11, 11, 10, 11, 11, 10, 10, 11, 10 } }; using (var arr = KhivaArray.Create(tss)) { var(p, i) = Matrix.StompSelfJoin(arr, 3); using (p) using (i) { float[] expectedIndex = { 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 9, 10, 11, 6, 7, 8, 3, 4, 5, 0, 1, 2 }; var pVal = p.GetData2D <float>(); var iVal = i.GetData2D <uint>(); for (var index = 0; index < 6; index++) { Assert.AreEqual(0.0, pVal[0, index], 1e-2); Assert.AreEqual(expectedIndex[index], iVal[0, index]); } } } }
public void TestFindBestNMotifs() { float[] tss = { 10, 10, 10, 10, 10, 10, 9, 10, 10, 10, 10, 10, 11, 10, 9 }; float[] tss2 = { 10, 11, 10, 9 }; using (KhivaArray arr = KhivaArray.Create(tss), arr2 = KhivaArray.Create(tss2)) { var(pArr, iArr) = Matrix.Stomp(arr, arr2, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNMotifs(pArr, iArr, 3, 1); using (distancesArr) using (indicesArr) using (subsequenceArr) { var indices = indicesArr.GetData1D <uint>(); var subsequence = subsequenceArr.GetData1D <uint>(); for (var i = 0; i < indices.Length; i++) { Assert.AreEqual(12, indices[i]); Assert.AreEqual(1, subsequence[i]); } } } } }
public void TestFindBestNDiscordsConsecutive() { float[] tss = { 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 9.999F, 9.998F }; using (var arr = KhivaArray.Create(tss)) { var(pArr, iArr) = Matrix.StompSelfJoin(arr, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNDiscords(pArr, iArr, 3, 2, true); using (distancesArr) using (indicesArr) using (subsequenceArr) { var subsequence = subsequenceArr.GetData1D <uint>(); Assert.AreEqual(12, subsequence[0]); var travis = Environment.GetEnvironmentVariable("TRAVIS"); if (travis != null) { Assert.AreEqual(11, subsequence[1]); } else { Assert.AreNotEqual(11, subsequence[1]); } } } } }
public void TestFindBestNDiscordsMirror() { float[] tss = { 10, 11, 10, 10, 11, 10 }; using (var arr = KhivaArray.Create(tss)) { var(pArr, iArr) = Matrix.StompSelfJoin(arr, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNDiscords(pArr, iArr, 3, 1, true); using (distancesArr) using (indicesArr) using (subsequenceArr) { var indices = indicesArr.GetData1D <uint>(); var subsequence = subsequenceArr.GetData1D <uint>(); for (var i = 0; i < indices.Length; i++) { Assert.AreEqual(3, indices[i]); Assert.AreEqual(1, subsequence[i]); } } } } }
public void TestFindBestNDiscordsMultipleProfiles() { double[,] tss = { { 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11 }, { 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11 } }; double[,] tss2 = { { 9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9 }, { 9, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 10.2, 10.1, 9 } }; using (KhivaArray arr = KhivaArray.Create(tss), arr2 = KhivaArray.Create(tss2)) { var(pArr, iArr) = Matrix.Stomp(arr, arr2, 3); using (pArr) using (iArr) { var(distancesArr, indicesArr, subsequenceArr) = Matrix.FindBestNDiscords(pArr, iArr, 3, 2); using (distancesArr) using (indicesArr) using (subsequenceArr) { var subsequence = subsequenceArr.GetData3D <uint>(); Assert.AreEqual(new uint[, , ] { { { 0, 10 }, { 0, 10 } }, { { 0, 10 }, { 0, 10 } } }, subsequence); } } } }
public void TestSquaredEuclidean() { int[,] tss = { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } }; int[,] expected = { { 0, 0, 0 }, { 64, 0, 0 }, { 256, 64, 0 } }; using (KhivaArray arr = KhivaArray.Create(tss), squaredEuclidean = Distances.SquaredEuclidean(arr)) { var result = squaredEuclidean.GetData2D <int>(); Assert.AreEqual(expected, result); } }
public void TestHamming() { int[,] tss = { { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 }, { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 5 } }; int[,] expected = { { 0, 0, 0, 0, 0 }, { 5, 0, 0, 0, 0 }, { 5, 5, 0, 0, 0 }, { 5, 5, 5, 0, 0 }, { 5, 5, 5, 5, 0 } }; using (KhivaArray arr = KhivaArray.Create(tss), hamming = Distances.Hamming(arr)) { var result = hamming.GetData2D <int>(); Assert.AreEqual(expected, result); } }
public void TestCountBellowMean() { float[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10, 11 } }; using (KhivaArray arr = KhivaArray.Create(tss), countBellowMean = Features.CountBelowMean(arr)) { var result = countBellowMean.GetData2D <uint>(); Assert.AreEqual(3, result[0, 0], Delta); Assert.AreEqual(3, result[1, 0], Delta); } }
public void TestGroupByDoubleKeyDoubleValueColumn() { float[,] tss = { { 0, 0, 0, 2, 2 }, { 2, 2, 2, 4, 4 }, { 0, 1, 2, 3, 4 }, { 1, 1, 1, 1, 1 } }; using (KhivaArray arr = KhivaArray.Create(tss), groupBy = Regularization.GroupBy(arr, 0, 2, 2)) { float[,] expected = { { 1, 3.5F }, { 1, 1 } }; var result = groupBy.GetData2D <float>(); Assert.AreEqual(expected, result); } }
public void TestGroupBySingleColumn() { int[,] tss = { { 0, 1, 1, 2, 2, 3 }, { 0, 3, 3, 1, 1, 2 } }; using (KhivaArray arr = KhivaArray.Create(tss), groupBy = Regularization.GroupBy(arr, 0)) { int[] expected = { 0, 3, 1, 2 }; var result = groupBy.GetData1D <int>(); Assert.AreEqual(expected, result); } }
public void TestC3() { float[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10, 11 } }; using (KhivaArray arr = KhivaArray.Create(tss), c3 = Features.C3(arr, 2)) { var result = c3.GetData2D <float>(); Assert.AreEqual(7.5, result[0, 0]); Assert.AreEqual(586.5, result[1, 0]); } }
public void TestEuclidean() { int[,] tss = { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } }; float[,] expected = { { 0, 0, 0 }, { 8, 0, 0 }, { 16, 8, 0 } }; using (KhivaArray arr = KhivaArray.Create(tss), euclidean = Distances.Euclidean(arr)) { var result = euclidean.GetData2D <float>(); Assert.AreEqual(expected, result); } }
public void TestAbsEnergy() { var tss = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; using (KhivaArray arr = KhivaArray.Create(tss), absEnergy = Features.AbsEnergy(arr)) { var result = absEnergy.GetData1D <int>(); Assert.AreEqual(385, result[0], Delta); } }
public void TestManhattan() { int[,] tss = { { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 }, { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 5 } }; int[,] expected = { { 0, 0, 0, 0, 0 }, { 5, 0, 0, 0, 0 }, { 10, 5, 0, 0, 0 }, { 15, 10, 5, 0, 0 }, { 20, 15, 10, 5, 0 } }; using (KhivaArray arr = KhivaArray.Create(tss), manhattan = Distances.Manhattan(arr)) { var result = manhattan.GetData2D <int>(); Assert.AreEqual(expected, result); } }
public void TestLls() { float[,] tss = { { 4, 3 }, { -1, -2 } }; float[] tss2 = { 3, 1 }; using (KhivaArray a = KhivaArray.Create(tss), b = KhivaArray.Create(tss2), lls = LinAlg.Lls(a, b)) { var result = lls.GetData2D <float>(); Assert.AreEqual(1, result[0, 0], Delta); Assert.AreEqual(1, result[0, 1], Delta); } }
public void TestPercentageOfReoccurringValuesToAllValues() { float[,] tss = { { 1, 1, 2, 3, 4, 4, 5, 6 }, { 1, 2, 2, 3, 4, 5, 6, 7 } }; using (KhivaArray arr = KhivaArray.Create(tss), percentage = Features.PercentageOfReoccurringValuesToAllValues(arr)) { var result = percentage.GetData2D <float>(); Assert.AreEqual(4.0 / 8.0, result[0, 0], 1e-4); Assert.AreEqual(2.0 / 8.0, result[1, 0], 1e-4); } }
public void TestPercentageOfReoccurringDatapointsToAllDatapoints() { float[,] tss = { { 3, 0, 0, 4, 0, 0, 13 }, { 3, 0, 0, 4, 0, 0, 13 } }; using (KhivaArray arr = KhivaArray.Create(tss), percentage = Features.PercentageOfReoccurringDatapointsToAllDatapoints(arr)) { var result = percentage.GetData2D <float>(); Assert.AreEqual(0.25, result[0, 0], 1e-4); Assert.AreEqual(0.25, result[1, 0], 1e-4); } }
public void TestLinearMultipleTimeSeries() { double[,] tss = { { 0.24580423, 0.59642861, 0.35879163, 0.37891011, 0.02445137, 0.23830957, 0.38793433, 0.68054104, 0.83934083, 0.76073689 }, { 0.24580423, 0.59642861, 0.35879163, 0.37891011, 0.02445137, 0.23830957, 0.38793433, 0.68054104, 0.83934083, 0.76073689 } }; double[,] tss2 = { { 0.2217416, 0.06344161, 0.77944375, 0.72174137, 0.19413884, 0.51146167, 0.06880307, 0.39414268, 0.98172767, 0.30490851 }, { 0.2217416, 0.06344161, 0.77944375, 0.72174137, 0.19413884, 0.51146167, 0.06880307, 0.39414268, 0.98172767, 0.30490851 } }; using (KhivaArray arr = KhivaArray.Create(tss), arr2 = KhivaArray.Create(tss2)) { var(slopeArr, interceptArr, rvalueArr, pvalueArr, stderrestArr) = Regression.Linear(arr, arr2); using (slopeArr) using (interceptArr) using (rvalueArr) using (pvalueArr) using (stderrestArr) { var slope = slopeArr.GetData2D <double>(); var intercept = interceptArr.GetData2D <double>(); var rvalue = rvalueArr.GetData2D <double>(); var pvalue = pvalueArr.GetData2D <double>(); var stderrest = stderrestArr.GetData2D <double>(); for (var i = 0; i < slope.GetLength(0); i++) { for (var j = 0; j < slope.GetLength(1); j++) { Assert.AreEqual(0.344864266, slope[i, j], Delta); Assert.AreEqual(0.268578232, intercept[i, j], Delta); Assert.AreEqual(0.283552942, rvalue[i, j], Delta); Assert.AreEqual(0.427239418, pvalue[i, j], Delta); Assert.AreEqual(0.412351891, stderrest[i, j], Delta); } } } } }
public void TestStdev() { double[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 2, 2, 2, 20, 30, 25 } }; using (KhivaArray arr = KhivaArray.Create(tss), stdev = Statistics.SampleStdevStatistics(arr)) { double[] expected = { 1.870828693, 12.988456413 }; var result = stdev.GetData2D <double>(); for (var i = 0; i < result.GetLength(0); i++) { Assert.AreEqual(expected[i], result[i, 0], 1e-2); } } }
public void TestSkewness() { double[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 2, 2, 2, 20, 30, 25 } }; using (KhivaArray arr = KhivaArray.Create(tss), skewness = Statistics.SkewnessStatistics(arr)) { double[] expected = { 0.0, 0.236177069879499 }; var result = skewness.GetData2D <double>(); for (var i = 0; i < result.GetLength(0); i++) { Assert.AreEqual(expected[i], result[i, 0], 1e-2); } } }
public void TestKurtosis() { double[,] tss = { { 0, 1, 2, 3, 4, 5 }, { 2, 2, 2, 20, 30, 25 } }; using (KhivaArray arr = KhivaArray.Create(tss), kurtosis = Statistics.KurtosisStatistics(arr)) { double[] expected = { -1.2, -2.66226722 }; var result = kurtosis.GetData2D <double>(); for (var i = 0; i < result.GetLength(0); i++) { Assert.AreEqual(expected[i], result[i, 0], 1e-2); } } }
public void TestCwtCoefficients() { double[,] tss = { { 0.1, 0.2, 0.3 }, { 0.1, 0.2, 0.3 } }; int[] width = { 1, 2, 3 }; using (KhivaArray arr = KhivaArray.Create(tss), widthArr = KhivaArray.Create(width), cwtCoeff = Features.CwtCoefficients(arr, widthArr, 2, 2)) { var result = cwtCoeff.GetData2D <float>(); Assert.AreEqual(0.26517161726951599, result[0, 0], Delta); Assert.AreEqual(0.26517161726951599, result[1, 0], Delta); } }