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