public override int CompareTo(HuffmanNode other)
{
var probComp = Probability.CompareTo(other.Probability);
if (probComp != 0)
{
return(probComp);
}
// Use size as tiebreaker to ensure a more balanced tree when probabilities match
var sizeComp = Size.CompareTo(other.Size);
if (sizeComp != 0)
{
return(sizeComp);
}
var casted = other as HuffmanDecision;
if (casted == null)
{
return(1);
}
var leftComp = Left.CompareTo(casted.Left);
if (leftComp != 0)
{
return(leftComp);
}
return(Right.CompareTo(casted.Right));
}
public void CompareTo_TransitiveDouble_ReturnsExpectedResult(double probabilityValue, double value2,
double value3, int expectedValue)
{
// Setup
var probability1 = new Probability(probabilityValue);
// Call
int probabilityResult12 = probability1.CompareTo(value2);
int probabilityResult23 = value2.CompareTo(value3);
int probabilityResult13 = probability1.CompareTo(value3);
// Assert
Assert.AreEqual(expectedValue, probabilityResult12);
Assert.AreEqual(expectedValue, probabilityResult23);
Assert.AreEqual(expectedValue, probabilityResult13);
}
public void CompareToTests(double left, double right, int expected)
{
Probability l = Probability.Create((decimal)left).Value;
Probability r = Probability.Create((decimal)right).Value;
int result = l.CompareTo(r);
result.Should().Be(expected);
}
public void CompareTo_Itself_ReturnsZero()
{
// Setup
var probability = new Probability(0);
// Call
int result = probability.CompareTo(probability);
// Assert
Assert.AreEqual(0, result);
}
public void CompareTo_Null_ReturnsExpectedResult()
{
// Setup
var probability = new Probability(0);
// Call
int result = probability.CompareTo(null);
// Assert
Assert.AreEqual(1, result);
}
public void CompareTo_ProbabilityToDouble_ReturnsExpectedResult(double probabilityValue, double value, int expectedIndex)
{
// Setup
var probability = new Probability(probabilityValue);
// Call
int probabilityResult = probability.CompareTo(value);
int doubleResult = value.CompareTo(probability);
// Assert
Assert.AreEqual(expectedIndex, probabilityResult);
Assert.AreEqual(-1 * expectedIndex, doubleResult);
}
public void CompareTo_ProbabilityToProbability_ReturnsExpectedResult(double probabilityValue, double probabilityValue2,
int expectedProbabilityIndex)
{
// Setup
var probability1 = new Probability(probabilityValue);
var probability2 = new Probability(probabilityValue2);
// Call
int probability1Result = probability1.CompareTo(probability2);
int probability2Result = probability2.CompareTo(probability1);
// Assert
Assert.AreEqual(expectedProbabilityIndex, probability1Result);
Assert.AreEqual(-1 * expectedProbabilityIndex, probability2Result);
}
public override int CompareTo(HuffmanNode other)
{
var probComp = Probability.CompareTo(other.Probability);
if (probComp != 0)
{
return(probComp);
}
// Use size as tiebreaker to ensure a more balanced tree when probabilities match
var sizeComp = Size.CompareTo(other.Size);
if (sizeComp != 0)
{
return(sizeComp);
}
var casted = other as HuffmanLeaf;
if (casted == null)
{
return(-1);
}
return(Symbol.CompareTo(casted.Symbol));
}
public int CompareTo(object obj)
{
return(-Probability.CompareTo(((HuffmanNode <T>)obj).Probability));
}
public int CompareTo(object obj)
{
return(Probability.CompareTo((obj as Alphabet).Probability));
}
public int CompareTo(AnaphoraCandidat other)
{
return(Probability.CompareTo(other.Probability));
}
int IComparable.CompareTo(object obj)
{
var temp = (HuffmanNode)obj;
return(Probability.CompareTo(temp.Probability));
}
