Fraction class in C#

public override string ToString() => ToString(false, false);

public string ToString(bool allowMixedNumeral, bool characterize = false) {
	if(Denominator == 1) {
		return Numerator.ToString();
	} else if(allowMixedNumeral) {
		var integer = (Numerator / Denominator);
		if(integer == 0) {
			if(characterize) {
				return _Characterize(Numerator, Denominator);
			} else {
				return $"{Numerator}/{Denominator}";
			}
		} else {
			var numerator = (Numerator % Denominator);
			if(numerator < 0) numerator = -numerator;
			if(characterize) {
				return $"{integer}{_Characterize(numerator, Denominator)}";
			} else {
				return $"{integer} {numerator}/{Denominator}";
			}
		}
	} else {
		if(characterize) {
			return _Characterize(Numerator, Denominator);
		} else {
			return $"{Numerator}/{Denominator}";
		}
	}
}

private static string _Characterize(long numerator, long denominator) => $"{_ToSuperscript(numerator)}⁄{_ToSubscript(denominator)}"; // uses Unicode "fraction slash" character

private static string _ToSuperscript(long value) {
	var ʀ = new StringBuilder();
	var negative = (value < 0);
	if(negative) {
		value = -value;
		ʀ.Append((char)0x207B); // Unicode superscript negative symbol
	}
	var text = value.ToString();
	foreach(var ɪ in text) {
		switch(ɪ) {
			// special cases...
			case '1': ʀ.Append((char)0x00B9); break; // Unicode superscript 1
			case '2':
			case '3': ʀ.Append((char)(ɪ + 0x0080)); break; // Unicode characters 0x00B2 and 0x00B3
			// Unicode range 0x2070–0x2079:
			default: ʀ.Append((char)(ɪ + 0x2040)); break;
		}
	}
	return ʀ.ToString();
}

private static string _ToSubscript(long value) {
	var text = value.ToString();
	var ʀ = new StringBuilder();
	foreach(var ɪ in text) ʀ.Append((char)(ɪ + 0x2050)); // Unicode range 0x2080–0x2089
	return ʀ.ToString();
}

var prettyFraction = (new Fraction(-5,4)).ToString(true, true));

-1¹⁄₄

        public static Fraction ToFraction(string inValue)
        {
            if (inValue == null || inValue == string.Empty)
                throw new ArgumentNullException("inValue");

            // could also be NumberFormatInfo.InvariantInfo
            NumberFormatInfo info = NumberFormatInfo.CurrentInfo;

            // Is it one of the special symbols for NaN and such...
            string trimmedValue = inValue.Trim();

            if (trimmedValue == info.NaNSymbol)
                return NaN;
            else if (trimmedValue == info.PositiveInfinitySymbol)
                return PositiveInfinity;
            else if (trimmedValue == info.NegativeInfinitySymbol)
                return NegativeInfinity;
            else
            {
                // Not special, is it a Fraction?
                int slashPos = inValue.IndexOf('/');

                if (slashPos > -1)
                {
                    // string is in the form of Numerator/Denominator
                    long numerator = Convert.ToInt64(inValue.Substring(0, slashPos));
                    long denominator = Convert.ToInt64(inValue.Substring(slashPos + 1));

                    return new Fraction(numerator, denominator);
                }
                else
                {
                    // the string is not in the form of a fraction
                    // hopefully it is double or integer, do we see a decimal point?

                    // make sure that we use CurrencyDecimalSeparator as decimal point
                    inValue = Regex.Replace(inValue, @"[\.\?,;/-]", CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator);

                    int decimalPos = inValue.IndexOf(info.CurrencyDecimalSeparator);

                    if (decimalPos > -1)
                        return new Fraction(Convert.ToDouble(inValue));
                    else
                        return new Fraction(Convert.ToInt64(inValue));
                }
            }
        }

      /// <summary>
      /// Converts a string to the corresponding reduced fraction
      /// </summary>
      /// <param name="inValue">The string representation of a fractional value</param>
      /// <returns>The Fraction that represents the string</returns>
      /// <remarks>Four forms are supported, as a plain integer, as a double, or as Numerator/Denominator
      /// and the representations for NaN and the infinites
/// 2013/6/19 Duane McKinney Added support for radios & percents</remarks>
      /// <example>"123" = 123/1 and "1.25" = 5/4 and "10/36" = 5/13 and NaN = 0/0 and
      /// PositiveInfinity = 1/0 and NegativeInfinity = -1/0 20%=1/5 1:10=1/10</example>
      public static Fraction ToFraction(string inValue)
      {
          if (inValue == null || inValue == string.Empty)
              throw new ArgumentNullException("inValue");

          // could also be NumberFormatInfo.InvariantInfo
          NumberFormatInfo info = NumberFormatInfo.CurrentInfo;

          // Is it one of the special symbols for NaN and such...
          string trimmedValue = inValue.Trim();

          if (trimmedValue == info.NaNSymbol)
              return NaN;
          else if (trimmedValue == info.PositiveInfinitySymbol)
              return PositiveInfinity;
          else if (trimmedValue == info.NegativeInfinitySymbol)
              return NegativeInfinity;
          else
          {
              // Not special, is it a Fraction?
              int slashPos = inValue.IndexOf('/');
    if (slashPos == -1)
      slashPos = inValue.IndexOf(':');

    int percentPos = inValue.IndexOf('%');

    long numerator = 0;

              if (slashPos > -1)
              {
                  // string is in the form of Numerator/Denominator
                  numerator = Convert.ToInt64(inValue.Substring(0, slashPos));
                  long denominator = Convert.ToInt64(inValue.Substring(slashPos + 1));

                  return new Fraction(numerator, denominator);
              }
    else if (percentPos > -1 && long.TryParse(inValue.Substring(0, percentPos), out numerator))
    {
      return new Fraction(numerator, 100);
    }
    else
    {
      // the string is not in the form of a fraction
      // hopefully it is double or integer, do we see a decimal point?
      int decimalPos = inValue.IndexOf(info.CurrencyDecimalSeparator);

      if (decimalPos > -1)
        return new Fraction(Convert.ToDouble(inValue));
      else
        return new Fraction(Convert.ToInt64(inValue));
    }
          }
      }

Mehroz.Fraction f1 = new Mehroz.Fraction(Math.Sqrt(2));

using System;
using System.Globalization;
using NUnit.Framework;
using Mehroz;

namespace TestFraction
{
    /// <summary>
    /// Testing Class
    /// </summary>
    [TestFixture()]
    public class TestFraction
    {

        [Test()]
        public void NaN()
        {
            Fraction frac=new Fraction(); // we'll get NaN
            Assert.AreEqual(Fraction.NaN,frac);
            Assert.AreEqual(NumberFormatInfo.CurrentInfo.NaNSymbol, frac.ToString());
        }


        [Test()]
        public void OneFifth()
        {
            Fraction frac = new Fraction(1,5);      // we'll get 1/5
            Assert.AreEqual("1/5", frac.ToString());

        }

        [Test()]
        public void TwentyFive()
        {
            Fraction frac=new Fraction(25);        // we'll get 25
            Assert.AreEqual("25", frac.ToString());
        }

        [Test()]
        public void Zero()
        {
            Fraction frac = new Fraction(0, 0);
            Assert.AreEqual("NaN", frac.ToString());
        }

        [Test()]
        public void OneFourthFromDecimal()
        {
            Fraction frac = new Fraction(0.25);
            Assert.AreEqual("1/4", frac.ToString());
        }

        [Test()]
        public void ThirtySevenFourthsFromDecimal()
        {
            Fraction frac = new Fraction(9.25);
            Assert.AreEqual("37/4", frac.ToString());
        }

        [Test()]
        public void LongMaxValDivbyZero()
        {
            Fraction frac = new Fraction(1, long.MaxValue);
            string compareTo = string.Format("1/{0}", long.MaxValue);
            Assert.AreEqual(compareTo, frac.ToString());
        }

        [Test()]
        public void LongMaxVal()
        {
            Fraction frac = new Fraction(long.MaxValue, 1);
            string compareTo = string.Format("{0}", long.MaxValue);
            Assert.AreEqual(compareTo,frac.ToString());
        }


        [Test()]
        public void TwoPlusOneIssue()
        {
            // the plus-one issue is because of twos-complement representing one more negtive value than
            // positive
            Fraction frac = new Fraction(long.MinValue + 1, 1);
            string compareTo = string.Format("{0}", long.MinValue + 1);
            Assert.AreEqual(compareTo, frac.ToString());
        }

        [Test()]
        public void LongMaxbyLongMax()
        {
            Fraction frac = new Fraction(long.MaxValue, long.MaxValue);
            Assert.AreEqual("1",frac.ToString());
        }

        [Test()]
        public void LongMinPlusOne()
        {
            Fraction frac = new Fraction(1, long.MinValue + 1);
            string compareTo = string.Format("-1/{0}", Math.Abs(long.MinValue + 1));
            Assert.AreEqual(compareTo,frac.ToString());
        }

        [Test()]
        public void LongMinByLongMin()
        {
            Fraction frac = new Fraction(long.MinValue + 1, long.MinValue + 1);
            Assert.AreEqual("1",frac.ToString());
        }

        [Test()]
        public void LongMaxByLongMinMinusOne()
        {
            Fraction frac=new Fraction(long.MaxValue, long.MinValue + 1);
            Assert.AreEqual("-1", frac.ToString());
        }

        [Test()]
        public void LongMinPlusOneByLongMax()
        {
            Fraction frac = new Fraction(long.MinValue + 1, long.MaxValue);
            Assert.AreEqual("-1", frac.ToString());
        }

        [Test()]
        public void OneFourthieth()
        {
            Fraction frac = new Fraction(0.025);    // we'll get 1/40
            Assert.AreEqual("1/40",frac.ToString());
        }

        [Test()]
        public void HalfFromFractionalTwo()
        {
            Fraction frac = new Fraction(1 / 2.0);  // we'll get 1/2
            Assert.AreEqual("1/2",frac.ToString() );
        }

        [Test()]
        public void ThirdFromFractionalThree()
        {
            Fraction frac = new Fraction(1 / 3.0);  // we'll get 1/3
            Assert.AreEqual("1/3", frac.ToString());
        }

        [Test()]
        public void QuarterFromFractionalFour()
        {
            Fraction frac = new Fraction(1 / 4.0);  // we'll get 1/4
            Assert.AreEqual("1/4",frac.ToString());
        }

        [Test()]
        public void FifthFromFractionalFive()
        {
            Fraction frac = new Fraction(1 / 5.0);  // we'll get 1/5
            Assert.AreEqual("1/5", frac.ToString());
        }

        [Test()]
        public void SixthFromFractionalSix()
        {
            Fraction frac = new Fraction(1 / 6.0);  // we'll get 1/6
            Assert.AreEqual("1/6",frac.ToString());
        }

        [Test()]
        public void SeventhFromFractionalSeven()
        {
            Fraction frac = new Fraction(1 / 7.0);  // we'll get 1/7
            Assert.AreEqual("1/7",frac.ToString());
        }

        [Test()]
        public void EigthFromFractionalEigt()
        {
            Fraction frac = new Fraction(1 / 8.0);  // we'll get 1/8
            Assert.AreEqual("1/8", frac.ToString());
        }

        [Test()]
        public void NinethFromFractionalNine()
        {
            Fraction frac = new Fraction(1 / 9.0);  // we'll get 1/9
            Assert.AreEqual("1/9",frac.ToString());
        }

        [Test()]
        public void TenthFromFractionalTen()
        {
            Fraction frac = new Fraction(1 / 10.0);  // we'll get 1/10
            Assert.AreEqual("1/10",frac.ToString());
        }

        [Test()]
        public void FourthyNinethFromFractional49()
        {
            Fraction frac = new Fraction(1 / 49.0);  // we'll get 1/49
            Assert.AreEqual("1/49",frac.ToString());
        }

        [Test()]
        public void SixFromIntSix()
        {
            Fraction frac = new Fraction(6); 
            Assert.AreEqual("6", frac.ToString() );
        }

        [Test()]
        public void FourFromIntFour()
        {
            Fraction frac = new Fraction(4);
            Assert.AreEqual("4",frac.ToString());
        }

        [Test()]
        public void Modulo2()
        {
            Fraction frac = new Fraction(6);
            Fraction divisor = new Fraction(4);
            frac %= divisor;
            Assert.AreEqual("2",frac.ToString() );
        }

        [Test()]
        public void FractionalDivision1()
        {
            Fraction frac = new Fraction(9,4);
            Fraction divisor = new Fraction(2);
            frac %= divisor;
            Assert.AreEqual("1/4",frac.ToString());
        }

        [Test()]
        public void FractionalDivision2()
        {
            Fraction frac = new Fraction(5, 12);
            Fraction divisor = new Fraction(1,4);
            frac %= divisor;
            Assert.AreEqual("1/6",frac.ToString());
        }

        [Test()]
        public void FromDecimal1()
        {
            Fraction frac = new Fraction(1.0);
            Assert.AreEqual("1",frac.ToString() );
        }

        [Test()]
        public void FromDecimal2()
        {
            Fraction frac = new Fraction(2.0);
            Assert.AreEqual("2",frac.ToString());
        }

        [Test()]
        public void FromDecimalMinus2()
        {
            Fraction frac = new Fraction(-2.0);
            Assert.AreEqual("-2",frac.ToString());
        }

        [Test()]
        public void FromDecimalMinus1()
        {
            Fraction frac = new Fraction(-1.0);
            Assert.AreEqual("-1",frac.ToString() );
        }

        [Test()]
        public void HalfFromDecimal()
        {
            Fraction frac = new Fraction(0.5);
            Assert.AreEqual("1/2",frac.ToString() );
        }

        [Test()]
        public void OneAndHalfFromDecimal()
        {
            Fraction frac = new Fraction(1.5);
            Assert.AreEqual("3/2",frac.ToString());
        }

        [Test()]
        public void LoopCheck()
        {
            for (int numerator = -100; numerator < 100; numerator++)
            {

                for (int denominator = -100; denominator < 100; denominator++)
                {
                    Fraction frac1 = new Fraction(numerator, denominator);

                    double dbl = (double)numerator / (double)denominator;
                    Fraction frac2 = new Fraction(dbl);

                    Assert.AreEqual(frac2,frac1);
                }
            }
        }


        [Test()]
        public void SixandQuarter()
        {
            Fraction frac = new Fraction("6.25");    // we'll get 25/4
            Assert.AreEqual("25/4", frac.ToString());
        }

        [Test()]
        public void AssignZero()
        {
            Fraction frac = new Fraction("0.5");
            frac = 0;
            Assert.AreEqual("0", frac.ToString() );
        }

        [Test()]
        public void AssignOne()
        {
            Fraction frac = new Fraction("0.5");
            frac = 1;
            Assert.AreEqual("1", frac.ToString() );
        }

        [Test()]
        public void PositiveInfinity()
        {
            Fraction frac = new Fraction("2");
            frac /= new Fraction(0);
            Assert.AreEqual(Fraction.PositiveInfinity, frac);
        }


        [Test()]
        public void NegativeInfinity()
        {
            Fraction frac = new Fraction("-1");
            frac /= new Fraction(0);
            Assert.AreEqual(Fraction.NegativeInfinity, frac);
        }

        [Test()]
        public void Addition()
        {
            Fraction frac = new Fraction("1/2");
            frac += new Fraction(2.5);
            Assert.AreEqual("3", frac.ToString());
        }

        [Test()]
        public void Deduction()
        {
            Fraction frac = new Fraction(0.5);
            frac -= new Fraction("1/4");
            Assert.AreEqual("1/4", frac.ToString());
        }

        [Test()]
        public void Equation1()
        {
            Fraction frac = new Fraction("1/2");

            //0.5 is not Fraction - no implicit conversion here
            Assert.IsFalse(frac.Equals(0.5));
        }


        [Test()]
        public void Equation2()
        {
            Fraction frac = new Fraction("1/2");
            Fraction frac1 = new Fraction(0.5);

            bool stmtm = frac==frac1;

            Assert.IsTrue(stmtm);
        }

        [Test()]
        public void Multiplication()
        {
            Fraction frac = new Fraction("1/3");
            frac *= 3;
            Assert.AreEqual("1", frac.ToString());
        }

        [Test()]
        public void Division()
        {
            Fraction frac = new Fraction("1/3");
            frac /= 15;
            Assert.AreEqual("1/45", frac.ToString());
        }


        [Test()]
        public void ImplicitCast1()
        {

            Fraction frac = new Fraction();
            frac = "1/2";            // implicit cast from string to fraction
            Assert.AreEqual("1/2", frac.ToString());
        }

        [Test()]
        public void ImplicitCast2()
        {

            Fraction frac = new Fraction();
            frac = "22.5";            // implicit cast from string to fraction
            Assert.AreEqual("45/2", frac.ToString());
        }

        [Test()]
        public void ImplicitCast3()
        {

            Fraction frac = new Fraction();
            frac = 10.25;            // implicit cast from double to fraction
            Assert.AreEqual("41/4", frac.ToString());
        }

        [Test()]
        public void ImplicitCast4()
        {

            Fraction frac = new Fraction();
            frac = 15;            // implicit cast from int/long to fraction
            Assert.AreEqual("15", frac.ToString());
        }


        [Test()]
        public void DoubleNan()
        {
            Fraction frac = new Fraction();
            frac = double.NaN;
            Assert.AreEqual(NumberFormatInfo.CurrentInfo.NaNSymbol,frac.ToString());
        }

        [Test()]
        public void DoublePositiveInfinity()
        {
            Fraction frac = new Fraction();
            frac = double.PositiveInfinity;
            Assert.AreEqual(NumberFormatInfo.CurrentInfo.PositiveInfinitySymbol,frac.ToString());
        }

        [Test()]
        public void DoubleNegativeInfinity()
        {
            Fraction frac = new Fraction();
            frac = double.NegativeInfinity;
            Assert.AreEqual(NumberFormatInfo.CurrentInfo.NegativeInfinitySymbol, frac.ToString());
        }

    }
}

            ///
            /// Get the value of the Fraction as a string, with proper representation for NaNs and infinites
            ///
            /// The string representation of the Fraction, or the culture-specific representations of
            /// NaN, PositiveInfinity or NegativeInfinity.
            /// The current culture determines the textual representation the Indeterminates
            public override string ToString()
            {
                if (this.m_Denominator == 1)
                {
                    return this.m_Numerator.ToString();
                }
                else if (this.m_Denominator == 0)
                {
                    return IndeterminateTypeName(this.m_Numerator);
                }
                else
                {
//UPDATE HERE TO SHOW INT + FRACTION FORM
                    if (this.m_Numerator > this.m_Denominator)
                    {
                        long div = this.m_Numerator / this.m_Denominator;
                        float rem = (float)this.m_Numerator / (float)this.m_Denominator - (float)div;
                        return div.ToString() + " " + new Fraction(rem).ToString();
                    }
                    else
                    {
                        return this.m_Numerator.ToString() + "/" + this.m_Denominator.ToString();
                    }
                }
            }

/// <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, quick-negate right and add (which is a subtraction)
	right.m_Numerator = -right.m_Numerator;
	Fraction difference = Add(this, right);
	
	if (difference.m_Numerator < 0)
		return -1;
	else if (difference.m_Numerator > 0)
		return 1;
	else
		return 0;
}

/*
 * Author: Syed Mehroz Alam
 * Email: smehrozalam@yahoo.com
 * URL: Programming Home "http://www.geocities.com/smehrozalam/" 
 * Date: 12/20/2004
 * Time: 06:30 PM
 *
 */

using System;
using System.Globalization;

namespace Mehroz
{
    /// <summary>
    /// Classes Contained:
    ///     Fraction
    ///     FractionException
    /// </summary>
    
    /// Class name: Fraction
    /// Developed by: Syed Mehroz Alam
    /// Email: mailto:smehrozalam@yahoo.com
    /// URL: http://www.geocities.com/smehrozalam/
    /// Changes: Marc C. Brooks  mailto:IDisposable@gmail.com
    ///          Jeffery Sax    http://www.extremeoptimization.com
    /// Version: 2.2
    /// 
    /// What's new in version 2.0:
    ///     *   Changed Numerator and Denominator from Int32(integer) to Int64(long) for increased range
    ///     *   renamed ConvertToString() to (overloaded) ToString()
    ///     *   added the capability of detecting/raising overflow exceptions
    ///     *   Fixed the bug that very small numbers e.g. 0.00000001 could not be converted to fraction
    ///     *   Other minor bugs fixed
    /// 
    /// What's new in version 2.1
    ///     *   overloaded user-defined conversions to/from Fractions
    ///
    /// What's new in version 2.2 - Marc C. Brooks   mailto:IDisposable@gmail.com
    ///     *   less overflows by finding the GCD for Add [Jeffery Sax] and Multiply [Marc C. Brooks]
    ///     *   understands and handles NaN, PositiveInfinity, NegativeInfinity just like double [Marc C. Brooks]
    ///     *   fixed several uses of int where long was correct [Marc C. Brooks]
    ///     *   made value-type (struct) [Jeffery Sax]
    ///     *   added ToInt32(), ToInt64() which throw for invalid (NaN, PositiveInfinity, NegativeInfinity) [Marc C. Brooks]
    ///     *   removed redundant Value property [Jeffery Sax]
    ///     *   added explicit conversion to Int32 and Int64 [Marc C. Brooks]
    ///     *   better handling of exceptions [Marc C. Brooks]
    ///     *   reorganize code, add XML doc and regions [Marc C. Brooks]
    ///     *   proper implementations of Equals [Marc C. Brooks, Jeffery Sax]
    ///     *   uses Math.Log(xx,2) and Math.Pow(xx,2) to get the best accuracy possible when converting doubles [Marc C. Brooks, Jeffery Sax]
    /// 
    /// Properties:
    ///     Numerator: Set/Get value for Numerator
    ///     Denominator:  Set/Get value for Numerator
    ///     [Note: If you Set either Property, the Fraction should be passed to ReduceFraction at some point.]
    /// 
    /// Constructors:
    ///     no arguments:   initializes fraction as 0/0 = NaN, so don't do that!
    ///     (Numerator, Denominator): initializes fraction with the given numerator and denominator 
    ///                               values and reduces
    ///     (long): initializes fraction with the given long value
    ///     (double):   initializes fraction with the given double value
    ///     (string):   initializes fraction with the given string value
    ///                 the string can be an in the form of and integer, double or fraction.
    ///                 e.g it can be like "123" or "123.321" or "123/456"
    /// 
    /// Public Methods (Description is given with respective methods' definitions)
    ///     Fraction ToFraction(long)
    ///     Fraction ToFraction(double)
    ///     Fraction ToFraction(string)
    ///     Int32 ToInt32()
    ///     Int64 ToInt64()
    ///     double ToDouble()
    ///     (override) string ToString()
    ///     Fraction Inverse()
    ///     Fraction Inverted(long)
    ///     Fraction Inverted(double)
    ///     ReduceFraction(ref Fraction)
    ///     CrossReducePair(ref Fraction, ref Fraction)
    ///     (override) Equals(object)
    ///     (override) GetHashCode()
    /// 
    /// Overloaded Operators (overloaded for Fractions, long and double)
    ///     Unary: -
    ///     Binary: +,-,*,/
    ///     Relational and Logical Operators: ==,!=,<,>,<=,>= (only == and != for long and doubles)
    /// 
    /// Overloaded user-defined conversions
    ///     Implicit:   From long/double/string to Fraction
    ///     Explicit:   From Fraction to long/double/string
    /// </summary>
    public struct Fraction
    {
        #region Constructors
        /// <summary>
        /// Construct a Fraction from an integral value
        /// </summary>
        /// <param name="wholeNumber">The value (eventual numerator)</param>
        /// <remarks>The denominator will be 1</remarks>
        public Fraction(long wholeNumber)
        {
            m_Numerator = wholeNumber;
            m_Denominator = 1;
            // no reducing required, we're a whole number
        }
    
        /// <summary>
        /// Construct a Fraction from a floating-point value
        /// </summary>
        /// <param name="floatingPointNumber">The value</param>
        public Fraction(double floatingPointNumber)
        {
            this = ToFraction(floatingPointNumber);
            // the best representation was built already, no reducing required
        }
        
        /// <summary>
        /// Construct a Fraction from a string in any legal format
        /// </summary>
        /// <param name="inValue">A string with a legal fraction input format</param>
        /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
        /// <see>ToFraction(string strValue)</see>
        public Fraction(string inValue)
        {
            this = ToFraction(inValue);
        }
        
        /// <summary>
        /// Construct a Fraction from a numerator, denominator pair
        /// </summary>
        /// <param name="numerator">The numerator (top number)</param>
        /// <param name="denominator">The denominator (bottom number)</param>
        /// <remarks>Will reduce the fraction to smallest possible denominator</remarks>
        public Fraction(long numerator, long denominator)
        {
            m_Numerator = numerator;
            m_Denominator = denominator;
            ReduceFraction(ref this);
        }

        /// <summary>
        /// Private constructor to synthesize a Fraction for indeterminates (NaN and infinites)
        /// </summary>
        /// <param name="type">Kind of inderterminate</param>
        private Fraction(Indeterminates type)
        {
            m_Denominator = 0;
            m_Numerator = (long)type;
            // do NOT reduce, we're clean as can be!
        }
        #endregion

        #region Properties
        /// <summary>
        /// The 'top' part of the fraction
        /// </summary>
        /// <example>For 3/4ths, this is the 3</example>
        public long Numerator
        {
            get 
            {
                return m_Numerator;
            }
            set
            {
                m_Numerator = value;
            }
        }

        /// <summary>
        /// The 'bottom' part of the fraction
        /// </summary>
        /// <example>For 3/4ths, this is the 4</example>
        public long Denominator
        {
            get
            {
                return m_Denominator;
            }
            set
            {
                m_Denominator = value;
            }
        }
        #endregion

        #region Explicit conversions
        #region To primitives
        /// <summary>
        /// Get the integral value of the Fraction object as int/Int32
        /// </summary>
        /// <returns>The (approximate) integer value</returns>
        /// <remarks>If the value is not a true integer, the fractional part is discarded
        /// (truncated toward zero). If the valid exceeds the range of an Int32 and exception is thrown.</remarks>
        /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
        /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
        /// <exception cref="OverflowException" Will throw a System.OverflowException if the value is too
        /// large or small to be represented as an Int32.</exception>
        public Int32 ToInt32()
        {
            if (this.Denominator == 0)
            {
                throw new FractionException(string.Format("Cannot convert {0} to Int32", IndeterminateTypeName(this.Numerator)), new System.NotFiniteNumberException());
            }

            long bestGuess = this.Numerator / this.Denominator;

            if (bestGuess > Int32.MaxValue || bestGuess < Int32.MinValue)
            {
                throw new FractionException("Cannot convert to Int32", new System.OverflowException());
            }

            return (Int32)bestGuess;
        }

        /// <summary>
        /// Get the integral value of the Fraction object as long/Int64
        /// </summary>
        /// <returns>The (approximate) integer value</returns>
        /// <remarks>If the value is not a true integer, the fractional part is discarded
        /// (truncated toward zero). If the valid exceeds the range of an Int32, no special
        /// handling is guaranteed.</remarks>
        /// <exception cref="FractionException">Will throw a FractionException for NaN, PositiveInfinity
        /// or NegativeInfinity with the InnerException set to a System.NotFiniteNumberException.</exception>
        public Int64 ToInt64()
        {
            if (this.Denominator == 0)
            {
                throw new FractionException(string.Format("Cannot convert {0} to Int64", IndeterminateTypeName(this.Numerator)), new System.NotFiniteNumberException());
            }

            return this.Numerator / this.Denominator;
        }

        /// <summary>
        /// Get the value of the Fraction object as double with full support for NaNs and infinities
        /// </summary>
        /// <returns>The decimal representation of the Fraction, or double.NaN, double.NegativeInfinity
        /// or double.PositiveInfinity</returns>
        public double ToDouble()
        {
            if (this.Denominator == 1)
                return this.Numerator;
            else if (this.Denominator == 0)
            {
                switch (NormalizeIndeterminate(this.Numerator))
                {
                    case Indeterminates.NegativeInfinity:
                        return double.NegativeInfinity;

                    case Indeterminates.PositiveInfinity:
                        return double.PositiveInfinity;

                    case Indeterminates.NaN:
                    default:    // this can't happen
                        return double.NaN;
                }
            }
            else
            {
                return (double)this.Numerator / (double)this.Denominator;
            }
        }

        /// <summary>
        /// Get the value of the Fraction as a string, with proper representation for NaNs and infinites
        /// </summary>
        /// <returns>The string representation of the Fraction, or the culture-specific representations of
        /// NaN, PositiveInfinity or NegativeInfinity.</returns>
        /// <remarks>The current culture determines the textual representation the Indeterminates</remarks>
        public override string ToString()
        {
            if (this.Denominator == 1)
            {
                return this.Numerator.ToString();
            }
            else if (this.Denominator == 0)
            {
                return IndeterminateTypeName(this.Numerator);
            }
            else
            {
                return this.Numerator.ToString() + "/" + this.Denominator.ToString();
            }
        }
        #endregion

        #region From primitives
        /// <summary>
        /// Converts a long value to the exact Fraction
        /// </summary>
        /// <param name="inValue">The long to convert</param>
        /// <returns>An exact representation of the value</returns>
        public static Fraction ToFraction(long inValue)
        {
            return new Fraction(inValue);
        }

        /// <summary>
        /// Converts a double value to the approximate Fraction
        /// </summary>
        /// <param name="inValue">The double to convert</param>
        /// <returns>A best-fit representation of the value</returns>
        /// <remarks>Supports double.NaN, double.PositiveInfinity and double.NegativeInfinity</remarks>
        public static Fraction ToFraction(double inValue)
        {
            if (double.IsNegativeInfinity(inValue))
            {
                return new Fraction(Indeterminates.NegativeInfinity);
            }
            else if (double.IsPositiveInfinity(inValue))
            {
                return new Fraction(Indeterminates.PositiveInfinity);
            }
            else if (double.IsNaN(inValue))
            {
                return new Fraction(Indeterminates.NaN);
            }
            else if (inValue % 1 == 0)  // if whole number
            {
                return new Fraction((Int64) inValue);
            }
            else
            {
                try
                {
                    checked
                    {
                        int sign = Math.Sign(inValue);
                        double numerator = Math.Abs(inValue);
                        long inScale = (long)Math.Log(numerator, 2);            // base two give "as exact as possible"
                        double denominator = Math.Pow(2, Math.Abs(inScale));    // start with at least enough...

                        return new Fraction((long)Math.Round(numerator * denominator * sign), (long)Math.Floor(denominator));
                    }
                }
                catch (Exception e)
                {
                    throw new FractionException("Assigned from double", e);
                }
            }
        }

        /// <summary>
        /// Converts a string to the corresponding reduced fraction
        /// </summary>
        /// <param name="inValue">The string representation of a fractional value</param>
        /// <returns>The Fraction that represents the string</returns>
        /// <remarks>Four forms are supported, as a plain integer, as a double, or as Numerator/Denominator
        /// and the representations for NaN and the infinites</remarks>
        /// <example>"123" = 123/1 and "1.25" = 5/4 and "10/36" = 5/13 and NaN = 0/0 and
        /// PositiveInfinity = 1/0 and NegativeInfinity = -1/0</example>
        public static Fraction ToFraction(string inValue)
        {
            if (inValue == null)
                throw new ArgumentNullException("inValue");

            // could also be NumberFormatInfo.InvariantInfo
            NumberFormatInfo info = NumberFormatInfo.CurrentInfo;

            // Is it one of the special symbols for NaN and such...
            string trimmedValue = inValue.Trim();

            if (trimmedValue == info.NaNSymbol)
                return new Fraction(Indeterminates.NaN);
            else if (trimmedValue == info.PositiveInfinitySymbol)
                return new Fraction(Indeterminates.PositiveInfinity);
            else if (trimmedValue == info.NegativeInfinitySymbol)
                return new Fraction(Indeterminates.NegativeInfinity);
            else
            {
                // Not special, is it a Fraction?
                int slashPos = inValue.IndexOf('/');

                if (slashPos > -1)
                {
                    // string is in the form of Numerator/Denominator
                    long numerator = Convert.ToInt64(inValue.Substring(0, slashPos));
                    long denominator = Convert.ToInt64(inValue.Substring(slashPos + 1));

                    return new Fraction(numerator, denominator);
                }
                else
                {
                    // the string is not in the form of a fraction
                    // hopefully it is double or integer, do we see a decimal point?
                    int decimalPos = inValue.IndexOf(info.CurrencyDecimalSeparator);

                    if (decimalPos > -1)
                        return new Fraction(Convert.ToDouble(inValue));
                    else
                        return new Fraction(Convert.ToInt64(inValue));
                }
            }
        }
        #endregion
        #endregion

        #region Indeterminate classifications
        /// <summary>
        /// Determines if a Fraction represents a Not-a-Number
        /// </summary>
        /// <returns>True if the Fraction is a NaN</returns>
        public bool IsNaN()
        {
            if (this.Denominator == 0 
                && NormalizeIndeterminate(this.Numerator) == Indeterminates.NaN)
                return true;
            else
                return false;
        }

        /// <summary>
        /// Determines if a Fraction represents Positive Infinity
        /// </summary>
        /// <returns>True if the Fraction is Positive Infinity</returns>
        public bool IsPositiveInfinity()
        {
            if (this.Denominator == 0
                && NormalizeIndeterminate(this.Numerator) == Indeterminates.PositiveInfinity)
                return true;
            else
                return false;
        }

        /// <summary>
        /// Determines if a Fraction represents Negative Infinity
        /// </summary>
        /// <returns>True if the Fraction is Negative Infinity</returns>
        public bool IsNegativeInfinity()
        {
            if (this.Denominator == 0
                && NormalizeIndeterminate(this.Numerator) == Indeterminates.NegativeInfinity)
                return true;
            else
                return false;
        }
        #endregion

        #region Inversion
        /// <summary>
        /// Inverts a Fraction
        /// </summary>
        /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
        /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
        public Fraction Inverse()
        {
            // don't use the obvious constructor because we do not want it normalized at this time
            Fraction frac = new Fraction();

            frac.Numerator = this.Denominator;
            frac.Denominator = this.Numerator;
            return frac;
        }

        /// <summary>
        /// Creates an inverted Fraction
        /// </summary>
        /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
        /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
        public static Fraction Inverted(long value)
        {
            Fraction frac = new Fraction(value);
            return frac.Inverse();
        }

        /// <summary>
        /// Creates an inverted Fraction
        /// </summary>
        /// <returns>The inverted Fraction (with Denominator over Numerator)</returns>
        /// <remarks>Does NOT throw for zero Numerators as later use of the fraction will catch the error.</remarks>
        public static Fraction Inverted(double value)
        {
            Fraction frac = new Fraction(value);
            return frac.Inverse();
        }
        #endregion

        #region Operators
        #region Unary Negation operator
        /// <summary>
        /// Negates the Fraction
        /// </summary>
        /// <param name="left">The Fraction to negate</param>
        /// <returns>The negative version of the Fraction</returns>
        public static Fraction operator -(Fraction left)
        {
            return Negate(left);
        }
        #endregion

        #region Addition operators
        public static Fraction operator +(Fraction left, Fraction right)
        {
            return Add(left, right);
        }
    
        public static Fraction operator +(long left, Fraction right)
        {
            return Add(new Fraction(left), right);
        }
    
        public static Fraction operator +(Fraction left, long right)
        {
            return Add(left, new Fraction(right));
        }

        public static Fraction operator +(double left, Fraction right)
        {
            return Add(ToFraction(left), right);
        }
    
        public static Fraction operator +(Fraction left, double right)
        {
            return Add(left, ToFraction(right));
        }
        #endregion

        #region Subtraction operators
        public static Fraction operator -(Fraction left, Fraction right)
        {
            return Add(left, - right);
        }
    
        public static Fraction operator -(long left, Fraction right)
        {
            return Add(new Fraction(left), - right);
        }
    
        public static Fraction operator -(Fraction left, long right)
        {
            return Add(left, new Fraction(- right));
        }

        public static Fraction operator -(double left, Fraction right)
        {
            return Add(ToFraction(left), - right);
        }
    
        public static Fraction operator -(Fraction left, double right)
        {
            return Add(left, ToFraction(- right));
        }
        #endregion

        #region Multiplication operators
        public static Fraction operator *(Fraction left, Fraction right)
        {
            return Multiply(left, right);
        }
    
        public static Fraction operator *(long left, Fraction right)
        {
            return Multiply(new Fraction(left), right);
        }
    
        public static Fraction operator *(Fraction left, long right)
        {
            return Multiply(left, new Fraction(right));
        }
    
        public static Fraction operator *(double left, Fraction right)
        {
            return Multiply(ToFraction(left), right);
        }
    
        public static Fraction operator *(Fraction left, double right)
        {
            return Multiply(left, ToFraction(right));
        }
        #endregion

        #region Division operators
        public static Fraction operator /(Fraction left, Fraction right)
        {
            return Multiply(left, right.Inverse());
        }
    
        public static Fraction operator /(long left, Fraction right)
        {
            return Multiply(new Fraction(left), right.Inverse());
        }
    
        public static Fraction operator /(Fraction left, long right)
        {
            return Multiply(left, Inverted(right));
        }
    
        public static Fraction operator /(double left, Fraction right)
        {
            return Multiply(ToFraction(left), right.Inverse());
        }
    
        public static Fraction operator /(Fraction left, double right)
        {
            return Multiply(left, Inverted(right));
        }
        #endregion

        #region Equal operators
        public static bool operator ==(Fraction left, Fraction right)
        {
            return left.Equals(right);
        }

        public static bool operator ==(Fraction left, long right)
        {
            return left.Equals(new Fraction(right));
        }

        public static bool operator ==(Fraction left, double right)
        {
            return left.Equals(new Fraction(right));
        }
        #endregion

        #region Not-equal operators
        public static bool operator !=(Fraction left, Fraction right)
        {
            return ! left.Equals(right);
        }

        public static bool operator !=(Fraction left, long right)
        {
            return ! left.Equals(new Fraction(right));
        }
        
        public static bool operator !=(Fraction left, double right)
        {
            return ! left.Equals(new Fraction(right));
        }
        #endregion

        #region Inequality operators
        /// <summary>
        /// Compares two Fractions to see if left is less than right
        /// </summary>
        /// <param name="left">The first Fraction</param>
        /// <param name="right">The second Fraction</param>
        /// <returns>True if <paramref name="left">left</paramref> is less
        /// than <paramref name="right">right</paramref></returns>
        /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
        /// <exception cref="FractionException">Throws an error if overflows occur while computing the 
        /// difference with an InnerException of OverflowException</exception>
        public static bool operator <(Fraction left, Fraction right)
        {
            // if left is an indeterminate, punt to the helper...
            if (left.Denominator == 0)
            {
                return IndeterminantLess(NormalizeIndeterminate(left.Numerator), right);
            }

            if (right.Denominator == 0)
            {
                // Only positive infinity compares favorably to real values
                return (NormalizeIndeterminate(right.Numerator) == Indeterminates.PositiveInfinity);
            }

            CrossReducePair(ref left, ref right);

            try
            {
                checked
                {
                    long leftScale = left.Numerator * right.Denominator;
                    long rightScale = left.Denominator * right.Numerator;

                    return leftScale < rightScale;
                }
            }
            catch (Exception e)
            {
                throw new FractionException("Compare < error", e);
            }
        }

        /// <summary>
        /// Compares two Fractions to see if left is greater than right
        /// </summary>
        /// <param name="left">The first Fraction</param>
        /// <param name="right">The second Fraction</param>
        /// <returns>True if <paramref name="left">left</paramref> is greater
        /// than <paramref name="right">right</paramref></returns>
        /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLess</see></remarks>
        /// <exception cref="FractionException">Throws an error if overflows occur while computing the 
        /// difference with an InnerException of OverflowException</exception>
        public static bool operator >(Fraction left, Fraction right)
        {
            // if right is an indeterminate, punt to the helper...
            if (right.Denominator == 0)
            {
                // Note: swapped arguments because we want greater.
                return IndeterminantLess(NormalizeIndeterminate(right.Numerator), left);
            }

            if (left.Denominator == 0)
            {
                // Only positive infinity compares favorably to real values
                return (NormalizeIndeterminate(left.Numerator) == Indeterminates.PositiveInfinity);
            }

            CrossReducePair(ref left, ref right);

            try
            {
                checked
                {
                    long leftScale = left.Numerator * right.Denominator;
                    long rightScale = left.Denominator * right.Numerator;

                    return leftScale > rightScale;
                }
            }
            catch (Exception e)
            {
                throw new FractionException("Compare > error", e);
            }
        }

        /// <summary>
        /// Compares two Fractions to see if left is less than or equal to right
        /// </summary>
        /// <param name="left">The first Fraction</param>
        /// <param name="right">The second Fraction</param>
        /// <returns>True if <paramref name="left">left</paramref> is less than or 
        /// equal to <paramref name="right">right</paramref></returns>
        /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
        /// <exception cref="FractionException">Throws an error if overflows occur while computing the 
        /// difference with an InnerException of OverflowException</exception>
        public static bool operator <=(Fraction left, Fraction right)
        {
            return ! (right > left);
        }
        
        /// <summary>
        /// Compares two Fractions to see if left is greater than or equal to right
        /// </summary>
        /// <param name="left">The first Fraction</param>
        /// <param name="right">The second Fraction</param>
        /// <returns>True if <paramref name="left">left</paramref> is greater than or 
        /// equal to <paramref name="right">right</paramref></returns>
        /// <remarks>Special handling for indeterminates exists. <see>IndeterminateLessEqual</see></remarks>
        /// <exception cref="FractionException">Throws an error if overflows occur while computing the 
        /// difference with an InnerException of OverflowException</exception>
        public static bool operator >=(Fraction left, Fraction right)
        {
            return ! (right < left);
        }
        #endregion

        #region Implict conversion from primitive operators
        /// <summary>
        /// Implicit conversion of a long integral value to a Fraction
        /// </summary>
        /// <param name="value">The long integral value to convert</param>
        /// <returns>A Fraction whose denominator is 1</returns>
        public static implicit operator Fraction(long value)
        {
            return new Fraction(value);
        }

        /// <summary>
        /// Implicit conversion of a double floating point value to a Fraction
        /// </summary>
        /// <param name="value">The double value to convert</param>
        /// <returns>A reduced Fraction</returns>
        public static implicit operator Fraction(double value)
        {
            return new Fraction(value);
        }

        /// <summary>
        /// Implicit conversion of a string to a Fraction
        /// </summary>
        /// <param name="value">The string to convert</param>
        /// <returns>A reduced Fraction</returns>
        public static implicit operator Fraction(string value)
        {
            return new Fraction(value);
        }
        #endregion

        #region Explicit converstion to primitive operators
        /// <summary>
        /// Explicit conversion from a Fraction to an integer
        /// </summary>
        /// <param name="frac">the Fraction to convert</param>
        /// <returns>The integral representation of the Fraction</returns>
        public static explicit operator int(Fraction frac)
        {
            return frac.ToInt32();
        }

        /// <summary>
        /// Explicit conversion from a Fraction to an integer
        /// </summary>
        /// <param name="frac">The Fraction to convert</param>
        /// <returns>The integral representation of the Fraction</returns>
        public static explicit operator long(Fraction frac)
        {
            return frac.ToInt64();
        }

        /// <summary>
        /// Explicit conversion from a Fraction to a double floating-point value
        /// </summary>
        /// <param name="frac">The Fraction to convert</param>
        /// <returns>The double representation of the Fraction</returns>
        public static explicit operator double(Fraction frac)
        {
            return frac.ToDouble();
        }

        /// <summary>
        /// Explicit conversion from a Fraction to a string
        /// </summary>
        /// <param name="frac">the Fraction to convert</param>
        /// <returns>The string representation of the Fraction</returns>
        public static implicit operator string(Fraction frac)
        {
            return frac.ToString();
        }
        #endregion
        #endregion

        #region Equals and GetHashCode overrides
        /// <summary>
        /// Compares for equality the current Fraction to the value passed.
        /// </summary>
        /// <param name="obj">A comparable object, a Fraction, a int/long, a float/double or a string</param>
        /// <returns>True if the value equals the current fraction, false otherwise (including for
        /// unsupported types or null object.</returns>
        public override bool Equals(object obj)
        {
            if (obj == null)
                return false;

            try 
            {
                Fraction frac;

                if (obj is Fraction)
                    frac = (Fraction)obj;
                else if (obj is long)
                    frac = new Fraction((long)obj);
                else if (obj is int)
                    frac = new Fraction((int)obj);
                else if (obj is double)
                    frac = new Fraction((double)obj);
                else if (obj is float)
                    frac = new Fraction((float)obj);
                else if (obj is string)
                    frac = new Fraction((string)obj);
                else 
                    return false;

                // insure we're as close to normalized as possible first
                ReduceFraction(ref this);

                // now normalize the comperand
                ReduceFraction(ref frac);

                return (this.Numerator == frac.Numerator && this.Denominator == frac.Denominator);
            }
            catch
            {
                // can't throw in an Equals!
                return false;
            }
        }
        
        /// <summary>
        /// Returns a hash code generated from the current Fraction
        /// </summary>
        /// <returns>The hash code</returns>
        /// <remarks>Reduces (in-place) the Fraction first.</remarks>
        public override int GetHashCode()
        {
            // insure we're as close to normalized as possible first
            ReduceFraction(ref this);
            return Convert.ToInt32((Numerator ^ Denominator) & 0xFFFFFFFF);
        }
        #endregion

        #region Reduction
        /// <summary>
        /// Reduces (simplifies) a Fraction by dividing down to lowest possible denominator (via GCD)
        /// </summary>
        /// <param name="frac">The Fraction to be reduced [WILL BE MODIFIED IN PLACE]</param>
        /// <remarks>Modifies the input arguments in-place! Will normalize the NaN and infinites
        /// representation. Will set Denominator to 1 for any zero numerator. Moves sign to the
        /// Numerator.</remarks>
        /// <example>2/4 will be reduced to 1/2</example>
        public static void ReduceFraction(ref Fraction frac)
        {
            // clean up the NaNs and infinites
            if (frac.Denominator == 0)
            {
                frac.Numerator = (long)NormalizeIndeterminate(frac.Numerator);
                return;
            }

            // all forms of zero are alike.
            if (frac.Numerator == 0)
            {
                frac.Denominator = 1;
                return;
            }
            
            long iGCD = GCD(frac.Numerator, frac.Denominator);
            frac.Numerator /= iGCD;
            frac.Denominator /= iGCD;
        
            // if negative sign in denominator
            if ( frac.Denominator < 0 )
            {
                //move negative sign to numerator
                frac.Numerator = - frac.Numerator;
                frac.Denominator = - frac.Denominator;  
            }
        }

        /// <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.Denominator == 0 || frac2.Denominator == 0)
                return;

            long gcdTop = GCD(frac1.Numerator, frac2.Denominator);
            frac1.Numerator = frac1.Numerator / gcdTop;
            frac2.Denominator = frac2.Denominator / gcdTop;

            long gcdBottom = GCD(frac1.Denominator, frac2.Numerator);
            frac2.Numerator = frac2.Numerator / gcdBottom;
            frac1.Denominator = frac1.Denominator / gcdBottom;
        }
        #endregion

        #region Implementation
        #region Inequality helper
        /// <summary>
        /// Determines if the Fraction is less than the indeterminate type.
        /// </summary>
        /// <param name="frac1Type">What kind of indeterminate</param>
        /// <param name="frac2">The Fraction to compare</param>
        /// <returns>Returns true if indeterminate is less than the Fraction</returns>
        /// <remarks>NaN is less than anything except NaN and Negative Infinity. Negative Infinity is less
        /// than anything except Negative Infinity. Positive Infinity is not less than anything.</remarks>
        private static bool IndeterminantLess(Indeterminates frac1Type, Fraction frac2)
        {
            switch (frac1Type)
            {
                case Indeterminates.NaN:
                    // A NaN is less than any non-NaN except Negative Infinity
                    return ! (frac2.IsNaN() || frac2.IsNegativeInfinity());

                case Indeterminates.NegativeInfinity:
                    // Negative Infinity is less than anything except Negative Infinity
                    return ! frac2.IsNegativeInfinity();

                case Indeterminates.PositiveInfinity:
                    // Positive Infinity is NOT less than anything
                    return false;

                default:    // if this happens, something VERY wrong is going on...
                    return false;
            }
        }
        #endregion

        #region Math helpers
        /// <summary>
        /// Negates the Fraction
        /// </summary>
        /// <param name="frac">Value to negate</param>
        /// <returns>A new Fraction that is sign-flipped from the input</returns>
        private static Fraction Negate(Fraction frac)
        {
            return new Fraction( - frac.Numerator, frac.Denominator);
        }

        /// <summary>
        /// Adds two Fractions
        /// </summary>
        /// <param name="left">A Fraction</param>
        /// <param name="right">Another Fraction</param>
        /// <returns>Sum of the Fractions</returns>
        /// <exception cref="FractionException">Will throw if an overflow occurs when computing the
        /// GCD-normalized values.</exception>
        private static Fraction Add(Fraction left, Fraction right)
        {
            long gcd = GCD(left.Denominator, right.Denominator); // cannot return less than 1
            long leftDenominator = left.Denominator / gcd;
            long rightDenominator = right.Denominator / gcd;

            try
            {
                checked
                {
                    if (left.IsNaN() || right.IsNaN())
                        throw new ArithmeticException("Not-a-Number");

                    long numerator = left.Numerator * rightDenominator + right.Numerator * leftDenominator;
                    long denominator = leftDenominator * rightDenominator * gcd;

                    return new Fraction(numerator, denominator);
                }
            }
            catch (Exception e)
            {
                throw new FractionException("Add error", e);
            }
        }
    
        /// <summary>
        /// Multiplies two Fractions
        /// </summary>
        /// <param name="left">A Fraction</param>
        /// <param name="right">Another Fraction</param>
        /// <returns>Product of the Fractions</returns>
        /// <exception cref="FractionException">Will throw if an overflow occurs. Does a cross-reduce to 
        /// insure only the unavoidable overflows occur.</exception>
        private static Fraction Multiply(Fraction left, Fraction right)
        {
            // this would be unsafe if we were not a ValueType, because we would be changing the
            // caller's values.  If we change back to a class, must use temporaries
            CrossReducePair(ref left, ref right);

            try
            {
                checked
                {
                    if (left.IsNaN() || right.IsNaN())
                        throw new ArithmeticException("Not-a-Number");

                    long numerator = left.Numerator * right.Numerator;
                    long denominator = left.Denominator * right.Denominator;

                    return new Fraction(numerator, denominator);
                }
            }
            catch (Exception e)
            {
                throw new FractionException("Multiply error", e);
            }
        }

        /// <summary>
        /// Computes the greatest common divisor for two values
        /// </summary>
        /// <param name="left">One value</param>
        /// <param name="right">Another value</param>
        /// <returns>The greatest common divisor of the two values</returns>
        /// <example>(6, 9) returns 3 and (11, 4) returns 1</example>
        private static long GCD(long left, long right)
        {
            // take absolute values
            if (left < 0)
                left = - left;

            if (right < 0)
                right = - right;
            
            // if we're dealing with any zero or one, the GCD is 1
            if (left < 2 || right < 2)
                return 1;

            do
            {
                if (left < right)
                {
                    long temp = left;  // swap the two operands
                    left = right;
                    right = temp;
                }

                left %= right;
            } while (left != 0);

            return right;
        }
        #endregion

        #region Indeterminate helpers
        /// <summary>
        /// Gives the culture-related representation of the indeterminate types NaN, PositiveInfinity
        /// and NegativeInfinity
        /// </summary>
        /// <param name="numerator">The value in the numerator</param>
        /// <returns>The culture-specific string representation of the implied value</returns>
        /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
        private static string IndeterminateTypeName(long numerator)
        {
            // could also be NumberFormatInfo.InvariantInfo
            System.Globalization.NumberFormatInfo info = NumberFormatInfo.CurrentInfo;

            switch (NormalizeIndeterminate(numerator))
            {
                case Indeterminates.PositiveInfinity:
                    return info.PositiveInfinitySymbol;

                case Indeterminates.NegativeInfinity:
                    return info.NegativeInfinitySymbol;

                default:    // if this happens, something VERY wrong is going on...
                case Indeterminates.NaN:
                    return info.NaNSymbol;
            }
        }

        /// <summary>
        /// Gives the normalize representation of the indeterminate types NaN, PositiveInfinity
        /// and NegativeInfinity
        /// </summary>
        /// <param name="numerator">The value in the numerator</param>
        /// <returns>The normalized version of the indeterminate type</returns>
        /// <remarks>Only the sign and zero/non-zero information is relevant.</remarks>
        private static Indeterminates NormalizeIndeterminate(long numerator)
        {
            switch (Math.Sign(numerator))
            {
                case 1:
                    return Indeterminates.PositiveInfinity;

                case -1:
                    return Indeterminates.NegativeInfinity;

                default:    // if this happens, your Math.Sign function is BROKEN!
                case 0:
                    return Indeterminates.NaN;
            }
        }
        #endregion

        /// <summary>
        /// The actual members
        /// </summary>
        private long m_Numerator;
        private long m_Denominator;
        
        // These are used to represent the indeterminate with a Denominator of zero
        private enum Indeterminates
        {
            NaN = 0
            , PositiveInfinity = 1
            , NegativeInfinity = -1
        }
        #endregion
    }   //end class Fraction

    /// <summary>
    /// Exception class for Fraction, derived from System.Exception
    /// </summary>
    public class FractionException : Exception
    {
        /// <summary>
        /// Constructs a FractionException
        /// </summary>
        /// <param name="Message">String associated with the error message</param>
        /// <param name="InnerException">Actual inner exception caught</param>
        public FractionException(string Message, Exception InnerException) : base(Message, InnerException)
        {
        }
    }   //end class FractionException
}   //end namespace Mehroz