public void FloatNumberEqualityComparer() { var comparer = NumericUtilities.FloatNumberEqualityComparer <double>(); Assert.IsTrue(comparer.Equals(1.001, 1.001)); Assert.IsFalse(comparer.Equals(654.3210, 654.3211)); }
public void StandardErrorWeightedValues() { var vals = new List <WeightedValue> { new WeightedValue { Value = 2, Weight = 1 }, new WeightedValue { Value = 3, Weight = 1 }, new WeightedValue { Value = 5, Weight = 0 }, new WeightedValue { Value = 7, Weight = 0 }, new WeightedValue { Value = 11, Weight = 4 }, new WeightedValue { Value = 13, Weight = 1 }, new WeightedValue { Value = 17, Weight = 2 }, new WeightedValue { Value = 19, Weight = 1 }, new WeightedValue { Value = 23, Weight = 0 }, }; Assert.IsTrue(NumericUtilities.DoubleCompare(5.31507, Statistics.StandardError(vals))); }
public void VarianceWeightedValues() { var vals = new List <WeightedValue> { new WeightedValue { Value = 2, Weight = 1 }, new WeightedValue { Value = 3, Weight = 1 }, new WeightedValue { Value = 5, Weight = 0 }, new WeightedValue { Value = 7, Weight = 0 }, new WeightedValue { Value = 11, Weight = 4 }, new WeightedValue { Value = 13, Weight = 1 }, new WeightedValue { Value = 17, Weight = 2 }, new WeightedValue { Value = 19, Weight = 1 }, new WeightedValue { Value = 23, Weight = 0 }, }; Assert.IsTrue(NumericUtilities.DoubleCompare(28.25, Statistics.Variance(vals))); }
public void MergeSortFloat() { var values = new float[] { 3.14f, 66.6f, 42.5f, 0.567f, -867.3f, 55.7f, 14.3f }; Sort.MergeSort(values, NumericUtilities.FloatNumberComparer <float>()); Assert.IsTrue(TestHelper.IsSortedAscending(values)); }
public void VarianceSingleValues() { var vals = new List <double> { 7.45, 11.25, 29.87, 41.15, 47.12 }; Assert.IsTrue(NumericUtilities.DoubleCompare(248.572336, Statistics.Variance(vals))); }
public void Modus() { var vals = new List <double> { 1.5, 2, 3.1, 1.5, 6, 8.4, 1.5, 5 }; Assert.IsTrue(NumericUtilities.DoubleCompare(1.5, Statistics.Modus(vals))); }
public void MedianValuesEvenLength() { var vals = new List <double> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; Assert.IsTrue(NumericUtilities.DoubleCompare(4.5, Statistics.Median(vals))); }
public void GreatestCommonDivisor() { Assert.AreEqual(NumericUtilities.GreatestCommonDivisor(2, 3), 1); Assert.AreEqual(NumericUtilities.GreatestCommonDivisor(12, 8), 4); Assert.AreEqual(NumericUtilities.GreatestCommonDivisor(165, 15), 15); Assert.AreEqual(NumericUtilities.GreatestCommonDivisor(-8, 44), 4); Assert.AreEqual(NumericUtilities.GreatestCommonDivisor(41, 43), 1); }
public void FloatNumberComparer() { var comparer = NumericUtilities.FloatNumberComparer <double>(); Assert.IsTrue(comparer.Compare(1.0, 2.0) < 0); Assert.AreEqual(comparer.Compare(0.02, 0.02), 0); Assert.IsTrue(comparer.Compare(13.07, 11.22) > 0); }
public void AverageValue() { var list = new List <double> { 1.1, 5.4, 84.41, 51.25, 5.79, 66.22 }; Assert.IsTrue(NumericUtilities.DoubleCompare(35.695, Statistics.AverageValue(list))); Assert.IsTrue(NumericUtilities.DoubleCompare(35.695, Statistics.ExpectedValue(list))); }
public void StandardErrorSingleValues() { var vals = new List <double> { 7.45, 11.25, 29.87, 41.15, 47.12 }; var result = Statistics.StandardError(vals); Assert.IsTrue(NumericUtilities.DoubleCompare(15.7661769, Statistics.StandardError(vals))); }
public void LinkedListSort() { var list = new LinkedList <float> { -54.4f, 18.4f, 3.14f, 85.5f, -111.11f, 54.34f, 41.5f, 69.4f }; list.Sort(NumericUtilities.FloatNumberComparer <float>()); Assert.IsTrue(TestHelper.IsSortedAscending(list)); }
public void IsPrime() { Assert.IsTrue(NumericUtilities.IsPrime(2)); Assert.IsTrue(NumericUtilities.IsPrime(31)); Assert.IsTrue(NumericUtilities.IsPrime(17)); Assert.IsFalse(NumericUtilities.IsPrime(4)); Assert.IsFalse(NumericUtilities.IsPrime(1)); Assert.IsFalse(NumericUtilities.IsPrime(55)); }
public void EratosthenesSieve() { var result = NumericUtilities.EratosthenesSieve(30); var expected = new List <uint> { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 }; Assert.IsTrue(result.SequenceEqual(expected)); }
public void CovarianceSingleValues() { var x = new List <double> { 65.21, 64.75, 65.26, 65.76, 65.96 }; var y = new List <double> { 67.25, 66.39, 66.12, 65.70, 66.64 }; Assert.IsTrue(NumericUtilities.DoubleCompare(-0.04644, Statistics.Covariance(x, y))); }
public void Corellation() { var x = new List <double> { 43, 21, 25, 42, 57, 59 }; var y = new List <double> { 99, 65, 79, 75, 87, 81 }; Assert.IsTrue(NumericUtilities.DoubleCompare(0.5298, Statistics.Corellation(x, y))); }
public void HeapSortAdvanced() { { var array = new int[] { -42, -42, 314, 22, 0, 41, 14, 11, 13, 13, 0, 5, -56, -800 }; Sort.HeapSort(array, TestHelper.DescedingComparer <int>()); Assert.IsTrue(TestHelper.IsSortedAscending(array.Reverse())); } { var array = new float[] { 0.225f, 2.4f, 888.8f, 42.424242f, 0.98f, 0.435f }; Sort.HeapSort(array, NumericUtilities.FloatNumberComparer <float>()); Assert.IsTrue(TestHelper.IsSortedAscending(array)); } }
public void BinaryHeapRemoveAll() { var heap = new BinaryHeap <float>(NumericUtilities.FloatNumberComparer <float>()) { 0.1f, 0.56f, 0.234f, 0.66f, 0.231f, 0.234f, 0.1f }; heap.RemoveAll(0.1f); Assert.IsTrue(heap.Comparer.Compare(0.231f, heap.Pop()) == 0); heap.RemoveAll(v => heap.Comparer.Compare(0.234f, v) == 0); Assert.IsTrue(heap.Comparer.Compare(0.56f, heap.Pop()) == 0); Assert.IsTrue(heap.Comparer.Compare(0.66f, heap.Pop()) == 0); Assert.AreEqual(heap.Count, 0); }
public void SplayTreeConstructorWithKeyComparer() { var tree = new SplayTree <double, int>(NumericUtilities.FloatNumberComparer <double>()); tree.Add(0.0000001, 0); var node = tree.Find(0.000001); Assert.IsTrue(node.HasValue); Assert.AreEqual(node.Value.Value, 0); tree.Add(0.00000012, 1); // Should overwrite previous inserted value node = tree.Find(0.00000012); Assert.IsTrue(node.HasValue); Assert.AreEqual(node.Value.Value, 1); }
public void MovingAverage() { var vals = new List <double> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; var expected = new List <double> { 6.0 / 3.0, 9.0 / 3.0, 12.0 / 3.0, 15.0 / 3.0, 18.0 / 3.0, 21.0 / 3.0, 24.0 / 3.0, 27.0 / 3.0 }; var result = Statistics.MovingAverage(vals, 3); result .Zip(expected, (res, exp) => NumericUtilities.DoubleCompare(res, exp)) .ToList() .ForEach(r => Assert.IsTrue(r)); }
public void LinearRegression() { var vals = new List <KeyValuePair <int, double> > { new KeyValuePair <int, double>(1, 5), new KeyValuePair <int, double>(2, 6), new KeyValuePair <int, double>(3, 8), new KeyValuePair <int, double>(4, 6), new KeyValuePair <int, double>(5, 7), }; double slope, offset; Statistics.LinearRegression(vals, out slope, out offset); Assert.IsTrue(NumericUtilities.DoubleCompare(0.4, slope)); Assert.IsTrue(NumericUtilities.DoubleCompare(5.2, offset)); }
public void MatrixCramersRuleValidResult() { var values = new double[, ] { { 8, -1, -2 }, { -1, 7, -1 }, { -2, -1, 9 } }; var result = new MatrixNxN <double>(values).CramersRule(new List <double> { 0, 10, 23 }); var expectedResult = new List <double> { 1, 2, 3 }; Assert.IsTrue(result.SequenceEqual(expectedResult, NumericUtilities.FloatNumberEqualityComparer <double>())); }
public void ElGamalLongMessageEncryption() { var elgamal = new SimpleElGamal(12, 17, 3, 74); var message = new List <uint> { 13, 7, 22, 43, 56, 64, 8, 1, 12 }; var expected = new List <uint>(); foreach (var value in message) { expected.Add(NumericUtilities.SolveModulo(value * elgamal.Key, 1, elgamal.Modulo)); } var encrypted = elgamal.Encrypt(message); Assert.IsTrue(expected.SequenceEqual(encrypted)); Assert.IsTrue(message.SequenceEqual(elgamal.Decrypt(encrypted))); }
public void MatrixGaussEliminationValidResult() { var values = new double[, ] { { 8, -1, -2, 0 }, { -1, 7, -1, 10 }, { -2, -1, 9, 23 } }; var matrix = new Matrix <double>(values); var resultType = matrix.GaussElimination(out List <double> result); Assert.AreEqual(resultType, GaussEliminationResultType.ValidResult); var expectedResult = new List <double> { 1, 2, 3 }; Assert.AreEqual(result .Zip(expectedResult, (r, e) => NumericUtilities.DoubleCompare(r, e)) .Count(a => a), 3); }
public void CovarianceWeightedValues() { var x = new List <WeightedValue> { new WeightedValue { Value = 65.21, Weight = 0.5 }, new WeightedValue { Value = 64.75, Weight = 0.5 }, new WeightedValue { Value = 65.26, Weight = 0.5 }, new WeightedValue { Value = 65.76, Weight = 0.5 }, new WeightedValue { Value = 65.96, Weight = 0.5 } }; var y = new List <WeightedValue> { new WeightedValue { Value = 67.25, Weight = 0.5 }, new WeightedValue { Value = 66.39, Weight = 0.5 }, new WeightedValue { Value = 66.12, Weight = 0.5 }, new WeightedValue { Value = 65.70, Weight = 0.5 }, new WeightedValue { Value = 66.64, Weight = 0.5 } }; Assert.IsTrue(NumericUtilities.DoubleCompare(-0.04644, Statistics.Covariance(x, y))); }
public void RSALongMessageEncryption() { var rsa = new SimpleRSA(3, 11); Assert.AreEqual(rsa.Modulo, 33u); Assert.AreEqual(rsa.PublicKey, 3u); Assert.AreEqual(rsa.PrivateKey, 7u); var message = new List <uint> { 1, 5, 31, 14, 8 }; var expected = new List <uint>(); foreach (var value in message) { expected.Add(NumericUtilities.SolveModulo(value, rsa.PublicKey, rsa.Modulo)); } var encrypted = rsa.Encrypt(message); Assert.IsTrue(expected.SequenceEqual(encrypted)); Assert.IsTrue(message.SequenceEqual(rsa.Decrypt(encrypted))); }
public void AverageValueWeight() { var list = new List <WeightedValue> { new WeightedValue { Weight = 5, Value = 12 }, new WeightedValue { Weight = 0.2, Value = 5 }, new WeightedValue { Weight = 1, Value = 14 }, new WeightedValue { Weight = 0.67, Value = 13 }, new WeightedValue { Weight = 1.7, Value = 55 }, }; var result = 20.67794632; Assert.IsTrue(NumericUtilities.DoubleCompare(result, Statistics.AverageValue(list))); }
public void MatrixDivision() { var values1 = new double[, ] { { 1, 2, 3 }, { 5, 6, 7 }, { 0, 0, 0 } }; var values2 = new double[, ] { { -7, -9, 11 }, { 10, -14, -5 }, { 4, -10, 10 } }; var expectedValues = new double[, ] { { -281 / 963.0, -283 / 963.0, 913 / 1926.0 }, { -989 / 963.0, -763 / 963.0, 2761 / 1926.0 }, { 0, 0, 0 } }; var result = new MatrixNxN <double>(values1) / new MatrixNxN <double>(values2); Assert.IsTrue(result.SequenceEqual(Enumerable.Cast <double>(expectedValues), NumericUtilities.FloatNumberEqualityComparer <double>())); }
public void EratosthenesSieveEmpty() { Assert.AreEqual(NumericUtilities.EratosthenesSieve(0).Count, 0); }
public void SolveModulo() { Assert.AreEqual(NumericUtilities.SolveModulo(2, 4, 5), 1u); Assert.AreEqual(NumericUtilities.SolveModulo(142, 41, 96), 64u); Assert.AreEqual(NumericUtilities.SolveModulo(2, 128, 41), 10u); }