From 61405b2caaa405eb209f19d62122e2b309be7c3e Mon Sep 17 00:00:00 2001 From: Ivan Pizhenko Date: Sun, 13 Aug 2017 12:36:08 +0300 Subject: [PATCH] Quantiles implementation and unit tests --- Contributors.txt | 4 +- Copyright.txt | 51 +++ .../Accord.Statistics/Measures.Vectors.cs | 388 +++++++++++++++++- .../Accord.Statistics/QuantilesTest.cs | 191 +++++++++ .../Accord.Tests.Math.csproj | 2 + .../Matrix/Matrix.Selection.cs | 3 +- 6 files changed, 631 insertions(+), 8 deletions(-) create mode 100644 Unit Tests/Accord.Tests.Math/Accord.Statistics/QuantilesTest.cs diff --git a/Contributors.txt b/Contributors.txt index 3e360ef83..9d80ba1cb 100644 --- a/Contributors.txt +++ b/Contributors.txt @@ -8,7 +8,6 @@ space below enlists a few of those people who either agreed to help or actively participated on its development: - - Anders Gustafsson - Antonino Porcino - Antonis Kalapodis @@ -19,6 +18,7 @@ - David Durrleman - Doug Blank - Hans Wolff + - Ivan Pizhenko - Marcos Diego Catalano - Max Bügler - Mathias Brandewinder @@ -48,4 +48,4 @@ community, notorious previous contributors are also listed below: - Markus Falkensteiner - Mladen Prajdic - Volodymyr Goncharov - - Yves Vander Haeghen \ No newline at end of file + - Yves Vander Haeghen diff --git a/Copyright.txt b/Copyright.txt index b2ecb7280..a6180a541 100644 --- a/Copyright.txt +++ b/Copyright.txt @@ -461,3 +461,54 @@ Snowball: A language for stemming algorithms LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + + Partitioning around medoids and Voronoi iteration algorithm for + the K-Medoids clustering: algorithm implementation and unit tests + + The MIT License (MIT) + + Copyright (c) 2017 Ivan Pizhenko + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + + + Statistical Quantiles: implementation and unit tests + + The MIT License (MIT) + + Copyright (c) 2017 Ivan Pizhenko + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. diff --git a/Sources/Accord.Math/Accord.Statistics/Measures.Vectors.cs b/Sources/Accord.Math/Accord.Statistics/Measures.Vectors.cs index a1eef84d2..c8425a996 100644 --- a/Sources/Accord.Math/Accord.Statistics/Measures.Vectors.cs +++ b/Sources/Accord.Math/Accord.Statistics/Measures.Vectors.cs @@ -2,8 +2,8 @@ // The Accord.NET Framework // http://accord-framework.net // -// Copyright © César Souza, 2009-2017 -// cesarsouza at gmail.com +// Copyright © 2009-2017 César Souza +// and other contrinbutors. // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -24,10 +24,8 @@ namespace Accord.Statistics { using System; using System.Collections.Generic; + using System.Linq; using Accord.Math; - using Accord.Math.Decompositions; - using AForge; - using System.Runtime.CompilerServices; /// /// Set of statistics measures, such as , @@ -1698,6 +1696,386 @@ public static double Entropy(IList values, int classes) return Entropy(values, 0, classes - 1); } + /// + /// Computes single quantile for the given sequence. + /// + /// The sequence of observations. + /// The quantile type, 1...9. + /// The auantile probability. + /// A boolean parameter informing if the given values have already been sorted. + /// Quantile value. + public static double Quantile(this IEnumerable x, int type, double p, bool alreadySorted = false) + { + return x.Quantiles(type, new double[] { p })[0]; + } + + /// + /// Computes multiple quantiles for the given sequence. + /// + /// The sequence of observations. + /// The sequence of quantile probabilities. + /// The quantile type, 1...9. + /// A boolean parameter informing if the given values have already been sorted. + /// Quantile value. + public static double[] Quantiles(this IEnumerable x, int type, IEnumerable p, bool alreadySorted = false) + { + if (type < 1 || type > 9) + throw new ArgumentException("Invalid quantile type, must be 1...9", "type"); + if (x == null) + throw new ArgumentNullException("Sequence of observations can't be null", "x"); + if (x.Count() == 0) + throw new ArgumentException("Sequence of observations can't be empty", "x"); + if (p == null) + throw new ArgumentNullException("Sequence of quantile probabilities can't be null", "p"); + if (p.Count() == 0) + throw new ArgumentNullException("Sequence of quantile probabilities can't be empty", "p"); + if (p.Any(pv => pv < 0.0 || pv > 1.0)) + throw new ArgumentException("There is invalid probability in the sequence of quantile probabilities", "p"); + + switch (type) + { + case 1: return Q1(x, p, alreadySorted); + case 2: return Q2(x, p, alreadySorted); + case 3: return Q3(x, p, alreadySorted); + case 4: return Q4(x, p, alreadySorted); + case 5: return Q5(x, p, alreadySorted); + case 6: return Q6(x, p, alreadySorted); + case 7: return Q7(x, p, alreadySorted); + case 8: return Q8(x, p, alreadySorted); + case 9: return Q9(x, p, alreadySorted); + default: return null; // Should never happen, but just make C# Compiler happy. + } + } + + /// + /// 1/3 constant. + /// + private static readonly double ONE_THIRD = 1.0 / 3; + + /// + /// 2/3 constant. + /// + private static readonly double TWO_THIRDS = 2.0 / 3; + + // +++ Checked, result matches to R + private static double[] Q1(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling(orderedX.Length * p.Max()); + if (n > 0) n--; + orderedX.NthElement(n); + } + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv == 0.0) + { + result[resultIndex] = orderedX[0]; + } + else + { + int i = (int)Math.Ceiling(orderedX.Length * pv); + if (i > 0) i--; + result[resultIndex] = orderedX[i]; + } + resultIndex++; + } + return result; + } + + // +++ Checked, result differs from R + private static double[] Q2(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling(orderedX.Length * p.Max()) + 1; + if (n > orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv == 0.0) + { + result[resultIndex] = orderedX[0]; + } + else if (pv == 1.0) + { + result[resultIndex] = orderedX[orderedX.Length - 1]; + } + else + { + int i = (int)Math.Ceiling(orderedX.Length * pv); + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = (orderedX[i] + orderedX[i2]) / 2; + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q3(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling(orderedX.Length * p.Max()); + if (n > 0) n--; + orderedX.NthElement(n); + } + + double lowThreshold = 0.5 / orderedX.Length; + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv <= lowThreshold) + result[resultIndex] = orderedX[0]; + else + { + int i = (int)Math.Round(orderedX.Length * pv); + if (i > 0) --i; + result[resultIndex] = orderedX[i]; + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q4(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling(orderedX.Length * p.Max()) + 1; + if (n > orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double lowThreshold = 1.0 / orderedX.Length; + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv < lowThreshold) + result[resultIndex] = orderedX[0]; + else if (pv == 1.0) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = orderedX.Length * pv; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q5(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling(orderedX.Length * p.Max() + 0.5) + 1; + if (n > orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double lowThreshold = 0.5 / orderedX.Length; + double highThreshold = (orderedX.Length - 0.5) / orderedX.Length; + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv < lowThreshold) + result[resultIndex] = orderedX[0]; + else if (pv >= highThreshold) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = orderedX.Length * pv + 0.5; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q6(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling((orderedX.Length + 1) * p.Max()); + if (n > orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double lowThreshold = 0.5 / (orderedX.Length + 1); + double highThreshold = orderedX.Length / (double)(orderedX.Length + 1); + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv < lowThreshold) + result[resultIndex] = orderedX[0]; + else if (pv >= highThreshold) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = (orderedX.Length + 1) * pv; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q7(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling((orderedX.Length - 1) * p.Max() + 1); + if (n > orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv == 1.0) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = (orderedX.Length - 1) * pv + 1; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q8(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling((orderedX.Length + ONE_THIRD) * p.Max() + ONE_THIRD); + if (n >= orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double lowThreshold = TWO_THIRDS / (orderedX.Length + ONE_THIRD); + double highThreshold = (orderedX.Length - ONE_THIRD) / (orderedX.Length + ONE_THIRD); + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv < lowThreshold) + result[resultIndex] = orderedX[0]; + else if (pv >= highThreshold) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = (orderedX.Length + ONE_THIRD) * pv + ONE_THIRD; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + + // +++ Checked, result matches to R + private static double[] Q9(IEnumerable x, IEnumerable p, bool alreadySorted = false) + { + double[] orderedX = x.ToArray(); + if (!alreadySorted) + { + int n = (int)Math.Ceiling((orderedX.Length + 0.25) * p.Max() + 0.375); + if (n >= orderedX.Length) n = orderedX.Length; + if (n > 0) --n; + orderedX.NthElement(n); + } + + double lowThreshold = 0.625 / (orderedX.Length + 0.25); + double highThreshold = (orderedX.Length - 0.375) / (orderedX.Length + 0.25); + + double[] result = new double[p.Count()]; + int resultIndex = 0; + foreach (double pv in p) + { + if (pv < lowThreshold) + result[resultIndex] = orderedX[0]; + else if (pv >= highThreshold) + result[resultIndex] = orderedX[orderedX.Length - 1]; + else + { + double h = (orderedX.Length + 0.25) * pv + 0.375; + double hc = Math.Floor(h); + int i = (int)hc; + if (i > 0) --i; + int i2 = i + 1; + if (i2 == orderedX.Length) i2--; + result[resultIndex] = orderedX[i] + (h - hc) * (orderedX[i2] - orderedX[i]); + } + resultIndex++; + } + return result; + } + } } diff --git a/Unit Tests/Accord.Tests.Math/Accord.Statistics/QuantilesTest.cs b/Unit Tests/Accord.Tests.Math/Accord.Statistics/QuantilesTest.cs new file mode 100644 index 0000000000..192f9ab8e --- /dev/null +++ b/Unit Tests/Accord.Tests.Math/Accord.Statistics/QuantilesTest.cs @@ -0,0 +1,191 @@ +// Accord Unit Tests +// The Accord.NET Framework +// http://accord-framework.net +// +// Copyright © 2009-2017 César Souza +// and other contributors. +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +// + +using System; +using Accord.Statistics; +using NUnit.Framework; + +namespace Accord.Tests.Statistics +{ + [TestFixture] + class QuantilesTest + { + private static readonly double[] EVEN_DATA = new double[] { 8.2, 6.2, 10.2, 20.2, 16.2, 15.2, 13.2, 3.2, 7.2, 8.2 }; + private static readonly double[] ODD_DATA = new double[] { 8.2, 6.2, 10.2, 9.2, 20.2, 16.2, 15.2, 13.2, 3.2, 7.2, 8.2 }; + private static readonly double[] TEST_PROBABILITIES = new double[] { 0.0, 0.25, 0.5, 0.75, 1.0 }; + + [Test] + public void Quantile1_Even() + { + var expected = new double[] { 3.2, 7.2, 8.2, 15.2, 20.2 }; + var actual = EVEN_DATA.Quantiles(1, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile1_Odd() + { + var expected = new double[] { 3.2, 7.2, 9.2, 15.2, 20.2 }; + var actual = ODD_DATA.Quantiles(1, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile2_Even() + { + var expected = new double[] { 3.2, 7.7, 9.2, 15.7, 20.2 }; + var actual = EVEN_DATA.Quantiles(2, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile2_Odd() + { + var expected = new double[] { 3.2, 7.7, 9.7, 15.7, 20.2 }; + var actual = ODD_DATA.Quantiles(2, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile3_Even() + { + var expected = new double[] { 3.2, 6.2, 8.2, 15.2, 20.2 }; + var actual = EVEN_DATA.Quantiles(3, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile3_Odd() + { + var expected = new double[] { 3.2, 7.2, 9.2, 13.2, 20.2 }; + var actual = ODD_DATA.Quantiles(3, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile4_Even() + { + var expected = new double[] { 3.2, 6.7, 8.2, 14.2, 20.2 }; + var actual = EVEN_DATA.Quantiles(4, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile4_Odd() + { + var expected = new double[] { 3.2, 6.95, 8.7, 13.7, 20.2 }; + var actual = ODD_DATA.Quantiles(4, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile5_Even() + { + var expected = new double[] { 3.2, 7.2, 9.2, 15.2, 20.2 }; + var actual = EVEN_DATA.Quantiles(5, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile5_Odd() + { + var expected = new double[] { 3.2, 7.45, 9.20, 14.7, 20.2 }; + var actual = ODD_DATA.Quantiles(5, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile6_Even() + { + var expected = new double[] { 3.2, 6.95, 9.2, 15.45, 20.2 }; + var actual = EVEN_DATA.Quantiles(6, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile6_Odd() + { + var expected = new double[] { 3.2, 7.2, 9.2, 15.2, 20.2 }; + var actual = ODD_DATA.Quantiles(6, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile7_Even() + { + var expected = new double[] { 3.2, 7.45, 9.2, 14.7, 20.2 }; + var actual = EVEN_DATA.Quantiles(7, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile7_Odd() + { + var expected = new double[] { 3.2, 7.7, 9.2, 14.2, 20.2 }; + var actual = ODD_DATA.Quantiles(7, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile8_Even() + { + var expected = new double[] { 3.2, 7.11666667, 9.2, 15.28333333, 20.2 }; + var actual = EVEN_DATA.Quantiles(8, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile8_Odd() + { + var expected = new double[] { 3.2, 7.36666667, 9.2, 14.86666667, 20.2 }; + var actual = ODD_DATA.Quantiles(8, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile9_Even() + { + var expected = new double[] { 3.2, 7.1375, 9.2, 15.2625, 20.2 }; + var actual = EVEN_DATA.Quantiles(9, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + [Test] + public void Quantile9_Odd() + { + var expected = new double[] { 3.2, 7.3875, 9.2, 14.8250, 20.2 }; + var actual = ODD_DATA.Quantiles(9, TEST_PROBABILITIES); + ArraysEqualWithThreshold(expected, actual); + } + + private static void ArraysEqualWithThreshold(double[] expected, double[] actual, + double differenceThreshold = 1e-8) + { + Assert.AreEqual(expected.Length, actual.Length, "Result length mismatch"); + for (int i = 0, n = expected.Length; i < n; i++) + { + Assert.AreEqual(expected[i], actual[i], differenceThreshold, + $"Value mismatch at index {i}"); + } + } + } +} diff --git a/Unit Tests/Accord.Tests.Math/Accord.Tests.Math.csproj b/Unit Tests/Accord.Tests.Math/Accord.Tests.Math.csproj index 093141f58..97cefba3b 100644 --- a/Unit Tests/Accord.Tests.Math/Accord.Tests.Math.csproj +++ b/Unit Tests/Accord.Tests.Math/Accord.Tests.Math.csproj @@ -59,6 +59,7 @@ --> + @@ -312,6 +313,7 @@ PreserveNewest +