public void GetPairWithIncreasingOrderMaximumDifference_TakesFuncIntoAccount()
{
var result =
Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 0, -10, 10, -11 }, (l, r) => Math.Abs(l - r));
Assert.AreEqual((0, -11), result);
}
public void GetEqualizationPairs_ReturnsAll_ForReversedSame()
{
var s = new[] { 1, 2, 3 };
var result = Pairing.GetEqualizationPairs(s, s.Reverse().ToArray());
TestHelper.AssertSequence(result, (3, 3), (2, 2), (1, 1));
}
public void GetPairsWithApproximateMinimumCost_ReturnsOnePair_ForTwoElementSequence()
{
var result = Pairing.GetPairsWithApproximateMinimumCost(new[] { 1, 2 }, DistanceCostOfPairsEvaluator);
Assert.AreEqual(1, result.Length);
Assert.IsTrue(result[0].Equals((1, 2)) || result[0].Equals((2, 1)));
}
public void GetPairsWithMinimumCost_OperatesAsExpected_AtLargeInputs(int length)
{
var random = new Random();
var sequence = new List <int>();
var expected = new Dictionary <int, int>();
for (var i = 0; i < length; i++)
{
var item = random.Next(length);
sequence.Add(item);
expected.AddOrUpdate(item, 1, e => e + 1);
}
var result = Pairing.GetPairsWithMinimumCost(sequence, DistanceCostOfPairsEvaluator);
foreach (var r in result)
{
var x = new[] { r.Item1, r.Item2 };
foreach (var item in x)
{
Assert.IsTrue(expected.TryGetValue(item, out var appearances));
if (appearances == 1)
{
expected.Remove(item);
}
else
{
expected[item] = appearances - 1;
}
}
}
Assert.AreEqual(0, expected.Count);
}
public void GetEqualizationPairs_ReturnsAll_ForSameSequence_3()
{
var s = new[] { 1, 2, 3 };
var result = Pairing.GetEqualizationPairs(s, s);
TestHelper.AssertSequence(result, (1, 1), (2, 2), (3, 3));
}
public void GetPairsWithApproximateMinimumCost_ApproximatesAtExpectedError(int length, int samples,
int iterations,
double expectedMaxError)
{
var totalError = .0;
for (var it = 0; it < samples; it++)
{
var random = new Random(Environment.TickCount);
var sequence = new List <int>();
for (var i = 0; i < length; i++)
{
var item = random.Next(length);
sequence.Add(item);
}
var approxResult =
Pairing.GetPairsWithApproximateMinimumCost(sequence, DistanceCostOfPairsEvaluator, iterations);
var approxCost = approxResult.Sum(s => DistanceCostOfPairsEvaluator(s.Item1, s.Item2));
sequence.Sort();
var minCost = .0;
var maxCost = .0;
for (var i = 0; i < sequence.Count; i += 2)
{
minCost += DistanceCostOfPairsEvaluator(sequence[i], sequence[i + 1]);
maxCost += DistanceCostOfPairsEvaluator(sequence[i], sequence[sequence.Count - i - 1]);
}
var error = 1 - (maxCost - approxCost) / (maxCost - minCost);
if (double.IsNaN(error))
{
error = 0;
}
totalError += error;
}
totalError /= samples;
Assert.IsTrue(totalError <= expectedMaxError,
$"Total error {totalError * 100:N}% should be less than or equal to {expectedMaxError * 100:N}%");
}
public void GetPairWithMaximumDifference_TakesComparerIntoAccount()
{
var result = Pairing.GetPairWithMaximumDifference(new[] { -1, 0, 1 }, Comparer <int> .Create((l, r) => r - l));
Assert.AreEqual((1, -1), result);
}
public void GetPairWithMaximumDifference_ReturnsThePair_ForTwoElements_2()
{
var result = Pairing.GetPairWithMaximumDifference(new[] { 2, 1 }, Comparer <int> .Default);
Assert.AreEqual((1, 2), result);
}
public void GetPairWithIncreasingOrderMaximumDifference_ReturnsThePair_ForTwoIncreasingElements()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 1, 2 }, Subtract);
Assert.AreEqual((1, 2), result);
}
public void GetPairWithIncreasingOrderMaximumDifference_ReturnsNull_ForEmptySequence()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new int[] { }, Subtract);
Assert.IsNull(result);
}
public void GetPairWithIncreasingOrderMaximumDifference_WorksForPerfectSequenceOfThree()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 0, 1, 2 }, Subtract);
Assert.AreEqual((0, 2), result);
}
public void GetPairWithMaximumDifference_WorksForNegative()
{
var result = Pairing.GetPairWithMaximumDifference(new[] { 0, -100, 100 }, Comparer <int> .Default);
Assert.AreEqual((-100, 100), result);
}
public void GetPairsWithMinimumCost_CreatesSets_UsingTheActualCost()
{
var result = Pairing.GetPairsWithMinimumCost(new[] { 1, 2, 3, 8, 9, 12, 4, 6 }, DistanceCostOfPairsEvaluator);
TestHelper.AssertSequence(result, (1, 2), (3, 4), (8, 6), (9, 12));
}
public void GetPairsWithMinimumCost_ThrowsException_ForSequenceWithOddNumberOfElements()
{
Assert.Throws <ArgumentException>(
() => Pairing.GetPairsWithMinimumCost(new[] { 1, 2, 3 }, BanalCostOfPairsEvaluator));
}
public void GetPairsWithMinimumCost_ThrowsException_ForNullSequence()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairsWithMinimumCost <int>(null, BanalCostOfPairsEvaluator));
}
public void GetPairsWithMinimumCost_ThrowsException_ForNullEvaluateCostOfPairFunc()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairsWithMinimumCost(new[] { 1, 2 }, null));
}
public void GetPairsWithApproximateMinimumCost_ThrowsException_ForZeroOrLessIterationCount()
{
Assert.Throws <ArgumentOutOfRangeException>(
() => Pairing.GetPairsWithApproximateMinimumCost(new[] { 1, 2 }, DistanceCostOfPairsEvaluator, 0));
}
public void GetPairWithMaximumDifference_ThrowsException_ForNullComparer()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairWithMaximumDifference(new int[] { }, null));
}
public void GetPairWithMaximumDifference_ThrowsException_ForNullSequence()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairWithMaximumDifference(null, Comparer <int> .Default));
}
public void GetPairsWithMinimumCost_ReturnsEmptyArray_ForEmptySequence()
{
var result = Pairing.GetPairsWithMinimumCost(new int[] { }, BanalCostOfPairsEvaluator);
TestHelper.AssertSequence(result);
}
public void GetPairWithIncreasingOrderMaximumDifference_WorksForNegative()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 0, -100, 100 }, Subtract);
Assert.AreEqual((0, 100), result);
}
public void GetPairsWithMinimumCost_ReturnsOnePair_ForTwoElementSequence()
{
var result = Pairing.GetPairsWithMinimumCost(new[] { 1, 2 }, BanalCostOfPairsEvaluator);
TestHelper.AssertSequence(result, (1, 2));
}
public void GetPairWithIncreasingOrderMaximumDifference_WorksInterruptedSequence_3()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 10, 20, 8, 19, 7, 19, 6 }, Subtract);
Assert.AreEqual((7, 19), result);
}
public void GetPairsWithMinimumCost_ReturnsTwoPairs_ForFourElementSequence()
{
var result = Pairing.GetPairsWithMinimumCost(new[] { 4, 10, 2, 8 }, BanalCostOfPairsEvaluator);
TestHelper.AssertSequence(result, (4, 10), (2, 8));
}
public void GetPairWithIncreasingOrderMaximumDifference_ReturnsNull_ForTwoDecreasingElements()
{
var result = Pairing.GetPairWithIncreasingOrderMaximumDifference(new[] { 2, 1 }, Subtract);
Assert.IsNull(result);
}
public void GetPairWithIncreasingOrderMaximumDifference_ThrowsException_ForNullFunc()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairWithIncreasingOrderMaximumDifference(new int[] { }, null));
}
public void GetPairWithMaximumDifference_ReturnsNull_ForEmptySequence()
{
var result = Pairing.GetPairWithMaximumDifference(new int[] { }, Comparer <int> .Default);
Assert.IsNull(result);
}
public void GetEqualizationPairs_ThrowsException_ForNullSequence1()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetEqualizationPairs(null, new int[] { }));
}
public void GetPairWithIncreasingOrderMaximumDifference_ThrowsException_ForNullSequence()
{
Assert.Throws <ArgumentNullException>(
() => Pairing.GetPairWithIncreasingOrderMaximumDifference((int[])null, Subtract));
}
public void GetPairWithMaximumDifference_ReturnsNull_ForOneElement()
{
var result = Pairing.GetPairWithMaximumDifference(new[] { 1 }, Comparer <int> .Default);
Assert.IsNull(result);
}
