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