Фракция вопрос сравнения в C#

Question

Существует что-то не так с сравнения> = метод:

public static bool operator >=(Fraction left, Fraction right) 
    { 
     return left.CompareTo(right) >= 0; 
    } 

Это не похоже на работу ?!

Например:

25> = 6/5 возвращает FALSE

Может кто-нибудь пролить некоторый свет на этот?

Ниже приведен код. Надеюсь, кто-то может понять, что с ним не так.

/// <summary> 
    /// Compares an object to this Fraction 
    /// </summary> 
    /// <param name="obj">The object to compare against (null is less than everything)</param> 
    /// <returns>-1 if this is less than <paramref name="obj"></paramref>, 
    /// 0 if they are equal, 
    /// 1 if this is greater than <paramref name="obj"></paramref></returns> 
    /// <remarks>Will convert an object from longs, doubles, and strings as this is a value-type.</remarks> 
    public int CompareTo(object obj) 
    { 
     if (obj == null) 
      return 1; // null is less than anything 

     Fraction right; 

     if (obj is Fraction) 
      right = (Fraction)obj; 
     else if (obj is long) 
      right = (long)obj; 
     else if (obj is double) 
      right = (double)obj; 
     else if (obj is string) 
      right = (string)obj; 
     else 
      throw new ArgumentException("Must be convertible to Fraction", "obj"); 

     return this.CompareTo(right); 
    } 

    /// <summary> 
    /// Compares this Fraction to another Fraction 
    /// </summary> 
    /// <param name="right">The Fraction to compare against</param> 
    /// <returns>-1 if this is less than <paramref name="right"></paramref>, 
    /// 0 if they are equal, 
    /// 1 if this is greater than <paramref name="right"></paramref></returns> 
    public int CompareTo(Fraction right) 
    { 
     // if left is an indeterminate, punt to the helper... 
     if (this.m_Denominator == 0) 
     { 
      return IndeterminantCompare(NormalizeIndeterminate(this.m_Numerator), right); 
     } 

     // if right is an indeterminate, punt to the helper... 
     if (right.m_Denominator == 0) 
     { 
      // note sign-flip... 
      return -IndeterminantCompare(NormalizeIndeterminate(right.m_Numerator), this); 
     } 

     // they're both normal Fractions 
     CrossReducePair(ref this, ref right); 

     try 
     { 
      checked 
      { 
       long leftScale = this.m_Numerator * right.m_Denominator; 
       long rightScale = this.m_Denominator * right.m_Numerator; 

       if (leftScale < rightScale) 
        return -1; 
       else if (leftScale > rightScale) 
        return 1; 
       else 
        return 0; 
      } 
     } 
     catch (Exception e) 
     { 
      throw new FractionException(string.Format("CompareTo({0}, {1}) error", this, right), e); 
     } 
    } 


    /// <summary> 
    /// Cross-reduces a pair of Fractions so that we have the best GCD-reduced values for multiplication 
    /// </summary> 
    /// <param name="frac1">The first Fraction [WILL BE MODIFIED IN PLACE]</param> 
    /// <param name="frac2">The second Fraction [WILL BE MODIFIED IN PLACE]</param> 
    /// <remarks>Modifies the input arguments in-place!</remarks> 
    /// <example>(3/4, 5/9) = (1/4, 5/3)</example> 
    public static void CrossReducePair(ref Fraction frac1, ref Fraction frac2) 
    { 
     // leave the indeterminates alone! 
     if (frac1.m_Denominator == 0 || frac2.m_Denominator == 0) 
      return; 

     long gcdTop = GCD(frac1.m_Numerator, frac2.m_Denominator); 
     frac1.m_Numerator = frac1.m_Numerator/gcdTop; 
     frac2.m_Denominator = frac2.m_Denominator/gcdTop; 

     long gcdBottom = GCD(frac1.m_Denominator, frac2.m_Numerator); 
     frac2.m_Numerator = frac2.m_Numerator/gcdBottom; 
     frac1.m_Denominator = frac1.m_Denominator/gcdBottom; 
    } 

Answer 1

Метод CrossReducePair, похоже, не имеет большого смысла. Как отмечается в комментариях, он преобразует (3/4, 5/9) в (1/4, 5/3). Примечание: 3/4 > 5/9, но 1/4 < 5/3.

Кроме того, очень плохо иметь метод CompareTo, который изменяет объект.

Answer 2

CrossReducePair изменяет соотношение между числами. Ваш пример (3/4, 5/9) = (1/4, 5/3) делает его очень очевидным. Крест-сокращение имеет смысл, если вы умножаетесь, но не, если вы просто сравниваете их.