public void SimplsComputeTest() { double[,] inputs; double[,] outputs; var pls = CreateWineExample(out inputs, out outputs); MultivariateLinearRegression regression = pls.CreateRegression(); // test factor proportions double[] expectedX = { 0.86, 0.12, 0.00, 0.86 }; double[] actualX = pls.Predictors.FactorProportions; Assert.IsTrue(expectedX.IsEqual(actualX, atol: 0.01)); double[] expectedY = { 0.67, 0.13, 0.17, 0.00 }; double[] actualY = pls.Dependents.FactorProportions; Assert.IsTrue(expectedY.IsEqual(actualY, atol: 0.01)); // Test Properties double[][] weights = pls.Weights; double[,] actual = pls.Predictors.Result; double[,] X0 = (double[, ])pls.Source.Clone(); Tools.Center(X0, inPlace: true); double[,] Y0 = (double[, ])pls.Output.Clone(); Tools.Center(Y0, inPlace: true); // XSCORES = X0*W double[][] expected = X0.Dot(weights); Assert.IsTrue(expected.IsEqual(actual, 0.01)); }
public void SkewnessMatrixTest() { double[][] matrix = { new double[] { 180 }, new double[] { 182 }, new double[] { 169 }, new double[] { 175 }, new double[] { 178 }, new double[] { 189 }, new double[] { 174 }, new double[] { 174 }, new double[] { 171 }, new double[] { 168 } }; double expected = 0.77771377; { double[] actual = Tools.Skewness(matrix); Assert.AreEqual(expected, actual[0], 1e-7); } { double actual = Tools.Skewness(matrix.GetColumn(0)); Assert.AreEqual(expected, actual, 1e-7); } }
public void CovarianceTest() { double[,] matrix = new double[, ] { { 4.0, 2.0, 0.60 }, { 4.2, 2.1, 0.59 }, { 3.9, 2.0, 0.58 }, { 4.3, 2.1, 0.62 }, { 4.1, 2.2, 0.63 } }; double[,] expected = new double[, ] { { 0.02500, 0.00750, 0.00175 }, { 0.00750, 0.00700, 0.00135 }, { 0.00175, 0.00135, 0.00043 }, }; double[,] actual = Tools.Covariance(matrix); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0001)); actual = Tools.Covariance(matrix, 0); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0001)); matrix = matrix.Transpose(); actual = Tools.Covariance(matrix, 1); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0001)); }
public void CovarianceTest6() { double[][] matrix = new double[, ] { { 4.0, 2.0, 0.60 }, { 4.2, 2.1, 0.59 }, { 3.9, 2.0, 0.58 }, { 4.3, 2.1, 0.62 }, { 4.1, 2.2, 0.63 } }.ToArray(); double[,] expected = new double[, ] { { 0.02500, 0.00750, 0.00175 }, { 0.00750, 0.00700, 0.00135 }, { 0.00175, 0.00135, 0.00043 }, }; double[] weights = { 1, 1, 1, 1, 1 }; double[,] actual = Tools.WeightedCovariance(matrix, weights, 0); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0001)); matrix = matrix.Transpose(); actual = Tools.WeightedCovariance(matrix, weights, 1); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.0001)); }
public void VarianceTest7() { double[][] matrix = new double[, ] { { 4.0, 2.0, 0.60 }, { 4.2, 2.1, 0.59 }, { 3.9, 2.0, 0.58 }, { 4.3, 2.1, 0.62 }, { 4.1, 2.2, 0.63 } }.ToArray(); double[] weights = { 0.9, 0.9, 0.9, 0.9, 0.9 }; double[] expected = { Tools.WeightedVariance(matrix.GetColumn(0), weights), Tools.WeightedVariance(matrix.GetColumn(1), weights), Tools.WeightedVariance(matrix.GetColumn(2), weights), }; double[] actual = Tools.WeightedVariance(matrix, weights); Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-10)); }
public void VarianceTest8() { double[,] matrix = { { 4.0, 2.0, 0.60 }, { 4.2, 2.1, 0.59 }, { 3.9, 2.0, 0.58 }, { 4.3, 2.1, 0.62 }, { 4.1, 2.2, 0.63 } }; double[] weights = { 0.9, 0.9, 0.9, 0.9, 0.9 }; double[] expected = { Tools.WeightedVariance(matrix.GetColumn(0), weights, WeightType.Automatic), Tools.WeightedVariance(matrix.GetColumn(1), weights, WeightType.Automatic), Tools.WeightedVariance(matrix.GetColumn(2), weights, WeightType.Automatic), }; double[] actual = Tools.WeightedVariance(matrix, weights, WeightType.Automatic); Assert.IsTrue(Matrix.IsEqual(expected, actual, 1e-10)); }
public void ExtendTest2() { int[][] data = { new int[] { 0, 2, 4 }, new int[] { 1, 1, 2 }, }; int labelColumn = 0; int positiveColumn = 1; int negativeColumn = 2; int[][] expected = { // For label 0 new int[] { 0, 1 }, // Two positive cases new int[] { 0, 1 }, new int[] { 0, 0 }, // Four negative cases new int[] { 0, 0 }, new int[] { 0, 0 }, new int[] { 0, 0 }, // For label 1 new int[] { 1, 1 }, // One positive case new int[] { 1, 0 }, // Three negative cases new int[] { 1, 0 }, }; int[][] actual = Tools.Expand(data, labelColumn, positiveColumn, negativeColumn); Assert.IsTrue(expected.IsEqual(actual)); }
public void CorrelationTest() { // http://www.solvemymath.com/online_math_calculator/statistics/descriptive/correlation.php double[,] matrix = new double[, ] { { 4.0, 2.0, 0.60 }, { 4.2, 2.1, 0.59 }, { 3.9, 2.0, 0.58 }, { 4.3, 2.1, 0.62 }, { 4.1, 2.2, 0.63 } }; double[,] expected = new double[, ] { { 1.000000, 0.5669467, 0.533745 }, { 0.566946, 1.0000000, 0.778127 }, { 0.533745, 0.7781271, 1.000000 } }; double[,] actual = Tools.Correlation(matrix); Assert.IsTrue(Matrix.IsEqual(expected, actual, 0.001)); }
public void GroupTest() { int[][] data = { new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 2, 1 }, new int[] { 2, 0 }, new int[] { 2, 0 }, new int[] { 2, 0 }, }; int[][] expected = { new int[] { 1, 4, 5 }, new int[] { 2, 1, 3 }, }; int[][] actual; actual = Tools.Group(data, 0, 1); Assert.IsTrue(Matrix.IsEqual(expected, actual)); }
public void KurtosisMatrixTest2() { double[][] matrix = { new double[] { 1987 }, new double[] { 1987 }, new double[] { 1991 }, new double[] { 1992 }, new double[] { 1992 }, new double[] { 1992 }, new double[] { 1992 }, new double[] { 1993 }, new double[] { 1994 }, new double[] { 1994 }, new double[] { 1995 }, }; double expected = 0.4466489; { double[] actual = Tools.Kurtosis(matrix); Assert.AreEqual(expected, actual[0], 1e-7); } { double actual = Tools.Kurtosis(matrix.GetColumn(0)); Assert.AreEqual(expected, actual, 1e-7); } }
public void MahalanobisTest() { double[] x = { 1, 0 }; double[,] y = { { 1, 0 }, { 0, 8 }, { 0, 5 } }; // Computing the mean of y double[] meanY = Tools.Mean(y); // Computing the covariance matrix of y double[,] covY = Tools.Covariance(y, meanY); // Inverting the covariance matrix double[,] precision = covY.Inverse(); // Run actual test double expected = 1.33333; double actual = Distance.SquareMahalanobis(x, meanY, precision); Assert.AreEqual(expected, actual, 0.0001); }
public void ExtendTest() { int[,] summary = { { 1, 4, 5 }, { 2, 1, 3 }, }; int[] group = summary.GetColumn(0); int[] positives = summary.GetColumn(1); int[] negatives = summary.GetColumn(2); int[][] expected = { new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 1 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 1, 0 }, new int[] { 2, 1 }, new int[] { 2, 0 }, new int[] { 2, 0 }, new int[] { 2, 0 }, }; int[][] actual; actual = Tools.Expand(group, positives, negatives); Assert.IsTrue(Matrix.IsEqual(expected, actual)); }
public void EntropyTest() { { int[] values = { 0, 1 }; int classes = 2; double expected = 1; double actual = Tools.Entropy(values, classes); Assert.AreEqual(expected, actual); } { int[] values = { 0, 0 }; int classes = 2; double expected = 0; double actual = Tools.Entropy(values, classes); Assert.AreEqual(expected, actual); } { int[] values = { 1, 1 }; int classes = 2; double expected = 0; double actual = Tools.Entropy(values, classes); Assert.AreEqual(expected, actual); } }
public void ModeTest1() { double[] values = { 3, 3, 1, 4 }; double expected = 3; double actual = Tools.Mode(values); Assert.AreEqual(expected, actual); }
public void SkewnessTest() { double[] values = { 3.4, 7.1, 1.5, 8.6, 4.9 }; double expected = -0.0061643641512110154; double actual = Tools.Skewness(values); Assert.AreEqual(expected, actual); }
public void MeanTest3() { double[] values = { -5, 0.2, 2 }; double expected = -0.93333333333333324; double actual = Tools.Mean(values); Assert.AreEqual(expected, actual); }
public void SkewnessTest() { double[] values = { 3.4, 7.1, 1.5, 8.6, 4.9 }; double expected = -0.00861496080010664; double actual = Tools.Skewness(values, false); Assert.AreEqual(expected, actual); }
public void ModeTest4() { int[] values = { 2, 5, 1, 6, 4, 1, 2, 6, 2, 6, 8, 2, 6, 2, 2 }; int expected = 2; int actual = Tools.Mode(values); Assert.AreEqual(expected, actual); }
public void SkewnessTest2() { Accord.Math.Random.Generator.Seed = 0; double[] values = Accord.Math.Vector.Random(10000000); double actual = Tools.Skewness(values, true); Assert.AreEqual(0.00046129386638486271, actual); }
public void KurtosisTest2() { Accord.Math.Random.Generator.Seed = 0; double[] values = Accord.Math.Vector.Random(10000000); double actual = Tools.Kurtosis(values, true); Assert.AreEqual(-1.1997826610738631, actual); }
public void StandardDeviationTest2() { double[] values = { -5, 0.2, 2 }; double expected = 3.6350149013908224; double actual = Tools.StandardDeviation(values); Assert.AreEqual(expected, actual); }
public void KurtosisTest() { double[] values = { 3.4, 7.1, 1.5, 8.6, 4.9 }; double expected = 1.6572340828415202; // definition used by STATA double actual = Tools.Kurtosis(values, false) + 3; Assert.AreEqual(expected, actual); }
public void KurtosisTest() { double[] values = { 3.4, 7.1, 1.5, 8.6, 4.9 }; double expected = -1.939370186981427; double actual = Tools.Kurtosis(values); Assert.AreEqual(expected, actual); }
public void RankTest1() { double[] values = { 2, 3, 4, 4, 5, 6, 8, 10, 10, 14, 16, 20, 32, 40 }; double[] expected = { 1, 2, 3.5, 3.5, 5, 6, 7, 8.5, 8.5, 10, 11, 12, 13, 14 }; double[] actual = Tools.Rank(values); Assert.IsTrue(expected.IsEqual(actual)); }
public void ModeTest3() { double[] values = { 0, 1, 2, 2 }; double expected = 2; double actual = Tools.Mode(values); Assert.AreEqual(expected, actual); }
public void QuartileTest2() { double[] values = new double[] { 1, 3, 3, 4, 5, 6, 6, 7, 8, 8 }; double q1, q3, actual; actual = Tools.Quartiles(values, out q1, out q3, false); Assert.AreEqual(3, q1); Assert.AreEqual(5.5, actual); Assert.AreEqual(7, q3); }
public void QuartileTest1() { double[] values = new double[] { 3, 4, 8 }; double q1, q3, actual; actual = Tools.Quartiles(values, out q1, out q3, false); Assert.AreEqual(3, q1); Assert.AreEqual(4, actual); Assert.AreEqual(8, q3); }
public void QuartileTest3() { double[] values = new double[] { 102, 104, 105, 107, 108, 109, 110, 112, 115, 116, 118 }; double q1, q3, actual; actual = Tools.Quartiles(values, out q1, out q3, false); Assert.AreEqual(105, q1); Assert.AreEqual(109, actual); Assert.AreEqual(115, q3); }
public void WeightedModeTest1() { double[] values = { 0, 1, 1, 2 }; double[] weights = { 50, 1, 1, 2 }; double expected = 0; double actual = Tools.WeightedMode(values, weights); Assert.AreEqual(expected, actual); }
public void WeightedCountsModeTest2() { double[] values = { 0, 1, 1, 2 }; int[] weights = { 0, 1, 1, 50 }; double expected = 2; double actual = Tools.WeightedMode(values, weights); Assert.AreEqual(expected, actual); }