C#实现的分数类

最近又对分数类做了一些修改，有些优化有些改写。

抄自python的限制分母大小的方法还是会有bug（Σ( ° △ °|||)︴。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Rainbow.Core
{
    public class Fraction : IComparable, IComparable<Fraction>, IEquatable<Fraction>
    {
        #region fields
        private long _numerator = 0;
        private long _denominator = 1;
        #endregion

        #region properties
        /// <summary>
        /// 分子
        /// </summary>
        public long Numerator
        {
            get { return _numerator; }
            set
            {
                SetNumAndDen(value, Denominator);
            }
        }
        /// <summary>
        /// 分母
        /// </summary>
        public long Denominator
        {
            get { return _denominator; }
            set
            {//分母分子不能同为负
                JudgeDenominator(value);
                SetNumAndDen(Numerator, value);
            }
        }
        /// <summary>
        /// 值
        /// </summary>
        public double Value
        {
            get { return Numerator / (double)Denominator; }
        }
        #endregion

        #region constructors

        public Fraction()
            : this(0, 1)
        { }

        public Fraction(long srcNum, long srcDen)
        {
            JudgeDenominator(srcDen);
            SetNumAndDen(srcNum, srcDen);
        }

        public Fraction(string srcNum, string srcDen)
        {
            long numerator, denominator;
            var result = Int64.TryParse(srcNum, out numerator);
            if (result == false)
                throw new Exception("Can not convert numerator:" + srcNum + " to a number.");
            result = Int64.TryParse(srcNum, out denominator);
            if (result == false)
                throw new Exception("Can not convert denominator:" + srcDen + " to a number.");

            JudgeDenominator(denominator);
            SetNumAndDen(numerator, denominator);
        }

        public Fraction(double srcDouble)
        {
            var tmp = ToFraction(srcDouble);
            SetNumAndDen(tmp.Numerator, tmp.Denominator);
        }

        public Fraction(string srcString)
        {
            var tmp = ToFraction(srcString);
            SetNumAndDen(tmp.Numerator, tmp.Denominator);
        }
        #endregion

        #region methods
        /// <summary>
        /// 设置分子分母值
        /// </summary>
        /// <param name="destNum"></param>
        /// <param name="destDen"></param>
        private void SetNumAndDen(long destNum, long destDen)
        {
            var negative = IsDifferentSign(destNum, destDen);
            _numerator = negative ? -Math.Abs(destNum) : Math.Abs(destNum);
            _denominator = Math.Abs(destDen);
        }
        /// <summary>
        /// 判断分母不为0
        /// </summary>
        /// <param name="srcDen"></param>
        private void JudgeDenominator(long srcDen)
        {
            if (srcDen == 0)
                throw new Exception("Denominator can not be zero.");
        }        
        /// <summary>
        /// 分子分母是否异号
        /// </summary>
        /// <param name="destNum"></param>
        /// <param name="destDen"></param>
        /// <returns></returns>
        private static bool IsDifferentSign(long destNum, long destDen)
        {
            return ((destNum >> 63) ^ (destDen >> 63)) == 1 ? true : false;
        }

        public static Fraction ToFraction(double srcDouble)
        {
            var result = new Fraction();
            try
            {
                checked
                {
                    string srcString = srcDouble.ToString();
                    double tmpNum = srcDouble;
                    long tmpDen = 1;
                    while (srcString.IndexOf('E') > 0)
                    {
                        tmpNum *= 10;
                        tmpDen *= 10;
                        srcString = tmpNum.ToString();
                    }
                    if (srcString.Contains('.'))
                    {
                        int lengthAfterDot = srcString.Split('.')[1].Length;
                        while (lengthAfterDot > 0)
                        {
                            tmpNum *= 10;
                            tmpDen *= 10;
                            lengthAfterDot--;
                        }
                    }
                    result = new Fraction((long)Math.Round(tmpNum), tmpDen);
                }
            }
            catch (OverflowException)
            {
                throw new Exception("Overflow while converting " + srcDouble + " to fraction.");
            }
            return result;
        }

        public static Fraction ToFraction(string srcString)
        {
            Fraction result = new Fraction();
            double srcDouble = 0;
            if (double.TryParse(srcString, out srcDouble))
            {//形如1.23，1E23
                result = ToFraction(srcDouble);
            }
            else if (new System.Text.RegularExpressions.Regex(@"^-?d+/-?d+$").IsMatch(srcString))
            {
                result = new Fraction(srcString.Split('/')[0], srcString.Split('/')[1]);
            }
            else
            {
                throw new Exception(string.Format("Failed while converting <{0}> to fraction.", srcString));
            }
            return result;
        }
        /// <summary>
        /// 约分
        /// </summary>
        /// <returns></returns>
        public Fraction ReduceNumAndDen()
        {
            var gcd = GreatestCommonDivisor(Numerator, Denominator);
            return new Fraction(Numerator / gcd, Denominator / gcd);
        }
        /// <summary>
        /// 辗转相除法求最大公约数
        /// </summary>
        /// <param name="srcBig"></param>
        /// <param name="srcSmall"></param>
        /// <returns></returns>
        private static long GreatestCommonDivisor(long srcBig, long srcSmall)
        {
            srcBig = Math.Abs(srcBig);
            srcSmall = Math.Abs(srcSmall);
            if (srcSmall > srcBig)
            {
                srcSmall = srcSmall ^ srcBig;
                srcBig = srcSmall ^ srcBig;
                srcSmall = srcSmall ^ srcBig;
            }
            if (srcBig % srcSmall == 0)
            {
                return srcSmall;
            }
            else
            {
                return GreatestCommonDivisor(srcSmall, srcBig % srcSmall);
            }
        }
        /// <summary>
        /// 限制分母最大值
        /// 抄自python，个别情况下会出异常
        /// </summary>
        /// <param name="srcMaxDen"></param>
        /// <returns></returns>
        public Fraction LimitDenominator(long srcMaxDen)
        {
            if (srcMaxDen < 1)            
                throw new Exception("Denominator should bigger than 0.");
            
            if (Denominator < srcMaxDen)            
                return this;
            
            try
            {
                long p0 = 0;
                long q0 = 1;
                long p1 = 1;
                long q1 = 0;
                long n = Numerator;
                long d = Denominator;
                while (true)
                {
                    long a = n / d;
                    long q2 = q0 + a * q1;
                    if (q2 > srcMaxDen)
                    {
                        break;
                    }
                    long p0Old = p0;
                    p0 = p1;
                    q0 = q1;
                    p1 = p0Old + a * p1;
                    q1 = q2;
                    long nOld = n;
                    n = d;
                    d = nOld - a * d;
                }
                long k = (srcMaxDen - q0) / q1;
                var result1 = new Fraction(p0 + k * p1, q0 + k * q1);
                var result2 = new Fraction(p1, q1);

                if (Math.Abs(result2.Value - this.Value) <= Math.Abs(result1.Value - this.Value))                
                    return result2;                
                else                
                    return result1;                
            }
            catch (DivideByZeroException)
            {
                //跟python结果不一致，要调查
                return this;
            }
        }
        #endregion

        #region ToString
        /// <summary>
        /// 转化为x/y形式
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return Denominator == 0 ? "NaN" : string.Format("{0}/{1}", Numerator, Denominator);
        }
        /// <summary>
        /// 转化为double字符串
        /// </summary>
        /// <returns></returns>
        public string ToDoubleString()
        {
            return Value.ToString();
        }
        #endregion

        #region interface

        #region IComparable<Fraction> 成员

        public int CompareTo(Fraction other)
        {
            return this.Value.CompareTo(other.Value);
        }

        #endregion

        #region IEquatable<Fraction> 成员

        public bool Equals(Fraction other)
        {
            return this == other;
        }

        #endregion

        #region IComparable 成员

        public int CompareTo(object obj)
        {
            int result;
            double tmpValue;
            if (obj == null)            
                throw new Exception("比较失败");            

            if (obj is string)
            {
                var strFrac = obj as string;
                if (this > ToFraction(strFrac))                
                    result = 1;
                else if (this < ToFraction(strFrac))                
                    result = -1;                
                else                
                    result = 0;                
            }
            else if (double.TryParse(obj as string, out tmpValue))
            {
                result = Value.CompareTo(tmpValue);
            }
            else
            {
                throw new Exception("比较失败");
            }
            return result;
        }

        #endregion

        #endregion

        /// <summary>
        /// fraction to double
        /// </summary>
        /// <param name="srcFrac"></param>
        /// <returns></returns>
        public static implicit operator double(Fraction srcFrac)
        {
            return srcFrac.Value;
        }

        #region operator

        //一元运算
        public static Fraction operator -(Fraction srcFrac)
        {
            return new Fraction(srcFrac.Numerator * -1, srcFrac.Denominator);
        }

        //二元逻辑运算
        public static bool operator >(Fraction left, Fraction right)
        {
            return left.Value > right.Value;
        }
        public static bool operator >=(Fraction left, Fraction right)
        {
            return left.Value >= right.Value;
        }
        public static bool operator <(Fraction left, Fraction right)
        {
            return left.Value < right.Value;
        }
        public static bool operator <=(Fraction left, Fraction right)
        {
            return left.Value <= right.Value;
        }
        public static bool operator ==(Fraction left, Fraction right)
        {
            return left.Value == right.Value;
        }
        public static bool operator !=(Fraction left, Fraction right)
        {
            return left.Value != right.Value;
        }

        //二元算术运算
        private static Fraction AddFraction(Fraction left, Fraction right)
        {
            var result = new Fraction();
            result.Denominator = left.Denominator * right.Denominator;
            result.Numerator = left.Numerator * right.Denominator + right.Numerator * left.Denominator;
            return result;
        }
        private static Fraction SubFraction(Fraction left, Fraction right)
        {
            var result = new Fraction();
            result.Denominator = left.Denominator * right.Denominator;
            result.Numerator = left.Numerator * right.Denominator - right.Numerator * left.Denominator;
            return result;
        }
        private static Fraction MultFraction(Fraction left, Fraction right)
        {
            var result = new Fraction();
            result.Denominator = left.Denominator * right.Denominator;
            result.Numerator = left.Numerator * right.Numerator;
            return result;
        }
        private static Fraction DivFraction(Fraction left, Fraction right)
        {
            var result = new Fraction();
            result.Denominator = left.Denominator * right.Numerator;
            result.Numerator = left.Numerator * right.Denominator;
            return result;
        }

        public static Fraction operator +(Fraction left, Fraction right)
        {
            return AddFraction(left, right);
        }
        public static Fraction operator -(Fraction left, Fraction right)
        {
            return SubFraction(left, right);
        }
        public static Fraction operator *(Fraction left, Fraction right)
        {
            return MultFraction(left, right);
        }
        public static Fraction operator /(Fraction left, Fraction right)
        {
            return DivFraction(left, right);
        }
        #endregion
    }
}