Fraction class in C# - CodeProject®

Introduction

This article demonstrates how to remove the problem of limited precision when numbers such as 1/10, 1/7, 1/3, etc. are represented in a floating point variable type in C#. Yes, you guessed it right, this problem can be solved by storing such numbers in a fraction format. As a fraction object stores its numerator and denominator as integer variables, there is no loss of accuracy. For this purpose, I have written a simple C# class representing fractions. It can be used in various applications, e.g., equation solving, matrix transformations, etc.

Features of class

The class contains a variety of overloaded constructors and operators for certain situations. It also throws certain exceptions, e.g., when denominator is tried to assign a 0 value, when the result of an arithmetic exceeds the limit (range), etc. One more feature is the automatic normalization (simplification) of fractions. The class uses data type 'long integer' for storing numerator and denominator, hence its range is upper bounded by the range of Int64 in .NET framework.

Using the code

The class includes a variety of constructors, e.g., one that takes an integer like 123, one that takes a double like 156.25, one that takes a string that has all the above qualities (e.g., string can be "32/77" or "213" or "321.44"), one that takes values of numerator and denominator like 231 and 101, and, of course, a parameter-less constructor for a "zero" fraction stored as 0/1.

Fraction frac=new Fraction(); // we'll get 0/1
frac=new Fraction(1,5);       // we'll get 1/5
frac=new Fraction(25);        // we'll get 25/1
frac=new Fraction(9.25);      // we'll get 37/4
frac=new Fraction("6.25");    // we'll get 25/4

frac=new Fraction( System.Console.ReadLine() );
     // we can enter anything like "213" or 
     // "23/3" or "4.27"

Console.WriteLine( frac );
// displays the current value of frac1 object;

Operators overloaded (overloaded for fractions, integers and doubles) for Fraction object include:

Unary: - (Negation)
Binary +, -, *, /
Relational operators such as ==, !=, <, >, <=, >=.

Fraction frac=new Fraction("1/2"); // initialize a fraction with 1/2
Console.WriteLine( frac+2.5 );     // will display 3

Overloaded conversion further enhances the capabilities of the class. See how simple it is to work with fractions:

Fraction frac="1/2" // implicit cast from string to 
frac="22.5"         // implicit cast from string to fraction
frac=10.25          // implicit cast from double to fraction
frac=15             // implicit cast from integer/long to fraction

Finally, as an exercise, guess the output of the following code:

Fraction f=0.5;                 // initialize frac=1/2
Console.WriteLine( f-0.25 );    // Yes, you are right. "1/4" is displayed
Console.WriteLine( f+"1/4" );
   // not sure??? It will display "3/4" because "1/4" has 
   // been converted to fraction and then added to our frac object

Implementation details

The class uses simple mathematics to do all the work. Let us see some of these simple techniques:

To convert a double to a fraction, we keep multiplying the given double number with 10 until it is converted to an integer number.
To convert a given string to a fraction, we treat all the value before "/" as numerator and after "/" as denominator.
To normalize a fraction, we divide its numerator and denominator by their GCD (found by famous Euler's formula).

To add two fractions, we use simple school formula to get numerator and denominator of the resultant fraction and then normalize it:

Numerator = frac1.Numerator*frac2.Denominator 
            + frac2.Numerator*frac1.Denominator;
Denominator = frac1.Denominator*frac2.Denominator;

To overload arithmetic operators for integers and doubles, we first convert them to fractions and then perform the operation.

Applications

There are a lot of applications of Fraction class. An example is a matrix class, see my article on Matrix class in C#.

History

Version 2.0

Changed Numerator and Denominator from Int32 (integer) to Int64 (long) for increased range.
Renamed ConvertToString() to 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.
Fixed other minor bugs.

Version 2.1

Overloaded conversions from/to fractions.

Version 2.2 (changes by Marc Brooks and Jeffrey Sax).

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]
Reorganized code, added 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]

Version 2.3 (changes by Marc Brooks and Jeffrey Sax)

Fixed double-to-fraction logic to use continued fraction rules to get best possible precision [bug fix for Syed Mehroz Alam, idea from Jeffery Sax]
Added static readonly values for NaN, PositiveInfinity, NegativeInfinity [idea from Jeffery Sax]
Moved comparisons into an implementation of IComparer [idea from Jeffery Sax]
No longer throws for NaN(s) involved in Add, Subtract, Multiply, Divide operations [idea from Jeffery Sax]
Added static readonly values for Zero, MinValue, MaxValue, Epsilon to better mirror double [Marc C. Brooks]
Added IsInfinity to better mirror double [Marc C. Brooks]
Added modulus and % operators [Marc C. Brooks]

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Syed Mehroz Alam

Software Developer

Pakistan

Member

Syed Mehroz Alam, living in Karachi, Pakistan, is a developer focusing Microsoft technologies. He has completed his bachelors as a Computer Systems Engineer in 2006 and is currently pursuing a Masters degree in Computer Science. He loves to learn, discover and master all aspects of .NET and SQL Server. Mehroz has developed rich internet enterprise applications using Silverlight in addition to the traditional ASP.NET and Windows Forms applications. He has worked with all three components of SQL Business Intelligence Studio: SSIS, SSRS and SSAS for developing BI Solutions and Data warehouse. He loves to write complex TSQL queries and evaluate his skills by participating in various TSQL Challenges. His blog can be viewed at http://smehrozalam.wordpress.com.

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

Unit tests for this class using NUnit

Syed Mehroz Alam

3:07 16 Feb '10

Got an email from Krzysztof Kniaz[^]. He has written the following NUnit tests to test this. Thanks Knaiz.

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

Regards,

Syed Mehroz Alam
My Blog | My Articles

Computers are incredibly fast, accurate, and stupid; humans are incredibly slow, inaccurate and brilliant; together they are powerful beyond imagination. - Albert Einstein

Thanks a million!

anhldbk

20:59 27 Oct '09

anhld
Sign In·View Thread·Permalink

Also check out the Fraction class from Apache

Sire404

4:03 27 Mar '09

Thanks for this class! However, if you need to reduce fractions with a max denominator (accepting rounding errors), check out the Apache implementation:

Manual:
http://commons.apache.org/math/apidocs/org/apache/commons/math/fraction/Fraction.html[^]

Source (java, very easy to convert):
http://www.apache.org/dev/version-control.html[^]

--------------------
No one is perfect. Welll, there was this guy... but we killed him.
coolquotescollection.com

gcd in binary

TheKing2

11:35 8 Mar '07

Apart from being an excellent class I'd like to note that the GCD method is done in base 10 arithmatic. It would benefit greatly if done in binary using binary shifts doing the division. I've located a C++ algorithm on wikipedia to do exactly that http://en.wikipedia.org/wiki/Binary_GCD_algorithm[^]
Sign In·View Thread·Permalink

Simple change

Daenris

14:26 24 Sep '06

Hey, I needed a fraction class that would display things like "1 1/2" and such, instead of showing it as 3/2.

A quick change to the ToSting() function provides this. Certainly not the best solution, but it was quick and it does what I needed. Great class all around though.

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

Re: Simple change

Daenris

14:33 24 Sep '06

Okay... that's what I get for posting before thinking. The last version introduced potential rounding problems... but using the following instead solves that.

if (this.m_Numerator > this.m_Denominator)
                    {
                        long div = this.m_Numerator / this.m_Denominator;
                        Fraction rem = new Fraction(this.m_Numerator - (div*this.m_Denominator),this.m_Denominator);
                        return div.ToString() + " " + rem.ToString();
                    }

Re: Simple change

dodiggitydag

16:10 12 Oct '06

Why not just encapsulate that method in a different method name? `ToMixedNumber()`
Sign In·View Thread·Permalink

A very good class

Mina Momtaz

23:33 13 May '06

this is a very good class. and i used it in my graduation project but do u have the c++ version or do u know any other jordan gaussian class but in c++ Mina Momtaz
Sign In·View Thread·Permalink

Bug in CompareTo(Fraction right) method.

Marc Brooks

8:25 9 Nov '05

An old coworker reported an error Confused | :confused:

to me when doing a comparison of 14/5 and 20/1 would yeild the wrong result. For some stupid Mad | :mad:

reason, I was doing a CrossReducePair (which is only safe when doing multiplication; comparisons are subtraction). Replace that method with this corrected version.

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

Sorry...

-- modified at 13:28 Wednesday 9th November, 2005

Some improvements for this class.

Marc C. Brooks

14:22 20 Dec '04

Thanks for this class! I needed something like this just the other day. I incorporated my needs and the changes suggested by Jeffery Sax.

It avoids most 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]

Due to limitations of the CodeProject message system, the XML docs have been stripped. If you want a copy of the revised class, just e-mail me

Here's the revised Fraction.cs class.

/*
 * 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

Re: Some improvements for this class.

Syed Mehroz Alam

21:06 20 Dec '04

Thank you very much for your nice work. You saved me from rewriting all the code again (taking into account all the suggestions by Jeffrey). I wrote such a simple and in-efficient(in many cases) class because all I wanted to do, was to write a matrix class using fractions so that I can verify my answers to questions of linear algebra.
Congratulations on your nice work.

Thanks,
Syed Mehroz Alam
Email: smehrozalam@yahoo.com
Homepage: Programming Home
URL: http://www.geocities.com/smehrozalam/

Re: Some improvements for this class.

Jeffrey Sax

22:28 20 Dec '04

Hi Marc,

Interesting implementation of 'indeterminates.' Maybe 'special values' would have been a better name. Infinities are quite determined. There are a few things you should be aware of, however:

Operations on NaNs do not throw exceptions. Instead, so the IEEE-754 standard for binary floating-point arithmetic[^] states, the return value should be once again NaN.

On that same note, you need to handle the special case that NaN != NaN is true. In fact, this is the only logical operation with a NaN operand that doesn't return false.

To be consistent with the rest of the Base Class Libraries, you may want to make these special values available as static readonly fields of the type. You may also want to add the related static methods defined in Double, like IsPositiveInfinity, etc.

Your implementation of Equals still doesn't comply with standard practices, although this is not stated as clearly as it should. Equals is used for object equality, and so should return false if the object being compared is not of type Fraction. Instead, the code in your Equals method belongs in a static, type safe Compare method that behaves like the Compare method of the IComparer interface. All logical operators should call this same method, or a st.

See the Shared Source CLI[^] for details.

The conversion from Double can be made simpler by decoding the 64 bit floating-point number. The binary layout is fixed by the CLI standard as that of IEEE-754 double-precision numbers, so it is safe to do this. The way to do this would be to use BitConverter.DoubleToInt64Bits to obtain a usable binary representation, and then move some bits around. This method is guaranteed to work, and is much faster than using Math.Log and Math.Pow.

You've added a lot of value to this class. Well done!

Jeffrey

Everything should be as simple as possible, but not simpler.
-- Albert Einstein
Numerical components for C# and VB.NET

Re: Some improvements for this class.

Marc Brooks

11:26 11 Jan '05

Jeffrey Sax wrote:

Operations on NaNs do not throw exceptions. Instead, so the IEEE-754 standard for binary floating-point arithmetic[^] states, the return value should be once again NaN.
Done. Changed Add and Multiply methods (used for all operations) to return NaN for operations involving left or right of NaN.

On that same note, you need to handle the special case that NaN != NaN is true. In fact, this is the only logical operation with a NaN operand that doesn't return false.
Done. Added a helper for comparing equality of two Fractions, made == and != call down to it. Double returns true from Equals if both values are NaN, so I do too.

Your implementation of Equals still doesn't comply with standard practices, although this is not stated as clearly as it should. Equals is used for object equality, and so should return false if the object being compared is not of type Fraction.
Done. The override now returns false for non-Fraction right-side, otherwise calls the new helper. Since Fraction is a value type, I wonder what object equality means in this case, so I just compare for same values after reduction.

Instead, the code in your Equals method belongs in a static, type safe Compare method that behaves like the Compare method of the IComparer interface. All logical operators should call this same method
Done. Added ICompare.CompareTo method. Since this is a value-type I made it handle the automatic conversions as appropriate. All the operator comparisons now use the type-safe CompareTo method (and internal helpers)

To be consistent with the rest of the Base Class Libraries, you may want to make these special values available as static readonly fields of the type
Done. Added Fraction.NaN, Fraction.PositiveInfinity and Fraction.NegativeInfinity. Also added MinValue, MaxValue and Epsilon. Also added Zero to deal with the issue of no-default constructor for structs (because it's a NaN otherwise).

You may also want to add the related static methods defined in Double, like IsPositiveInfinity, etc.
Those were already there. :grin: I did add IsInfinity

I also fixed the issues this code had with imprecise doubles (repeating decimals). I'm now using the repeating fraction logic I found here which does as good a job as possible and is relatively quick.

Here's the revised code:

	/*
	* Author: Syed Mehroz Alam
	* Email: smehrozalam@yahoo.com
	* URL: Programming Home "http://www.geocities.com/smehrozalam/" 
	*
	*/
 
	using System;
	using System.Runtime.InteropServices;
	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]
		///
		/// What's new in version 2.3 - Marc C. Brooks   mailto:IDisposable@gmail.com   01/10/2005
		///     *   fixed double-to-fraction logic to use continued fraction rules to get best possible precistion [bug fix for Syed Mehroz Alam, idea from  Jeffery Sax]
		///     *	added static readonly values for NaN, PositiveInfinity, NegativeInfinity [idea from Jeffery Sax]
		///     *	moved comparisons into an implementation of IComparer [idea from Jeffery Sax]
		///     *	no longer throws for NaN(s) involved in Add, Subtract, Multiply, Divide operations [idea from Jeffery Sax]
		///     *   added static readonly values for Zero, MinValue, MaxValue, Epsilon to better mirror double
		///     *   added IsInfinity to better mirror double.
		///     *   added Modulus and % operators
		///
		/// 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>
		[Serializable, StructLayout(LayoutKind.Sequential)]
		public struct Fraction : IComparable, IFormattable
		{
			#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)
			{
				if (wholeNumber == long.MinValue)
					wholeNumber++;	// prevent serious issues later..
 
				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);
			}
	        
			/// <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)
			{
				if (numerator == long.MinValue)
					numerator++;	// prevent serious issues later..
 
				if (denominator == long.MinValue)
					denominator++;	// prevent serious issues later..
 
				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_Numerator = (long)type;
				m_Denominator = 0;
				// 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 Expose constants
			public static readonly Fraction NaN = new Fraction(Indeterminates.NaN);
			public static readonly Fraction PositiveInfinity = new Fraction(Indeterminates.PositiveInfinity);
			public static readonly Fraction NegativeInfinity = new Fraction(Indeterminates.NegativeInfinity);
			public static readonly Fraction Zero = new Fraction(0,1);
			public static readonly Fraction Epsilon = new Fraction(1, Int64.MaxValue);
			private static readonly double EpsilonDouble = 1.0 / Int64.MaxValue;
			public static readonly Fraction MaxValue = new Fraction(Int64.MaxValue, 1);
			public static readonly Fraction MinValue = new Fraction(Int64.MinValue, 1);
			#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.m_Denominator == 0)
				{
					throw new FractionException(string.Format("Cannot convert {0} to Int32", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
				}
 
				long bestGuess = this.m_Numerator / this.m_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.m_Denominator == 0)
				{
					throw new FractionException(string.Format("Cannot convert {0} to Int64", IndeterminateTypeName(this.m_Numerator)), new System.NotFiniteNumberException());
				}
 
				return this.m_Numerator / this.m_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.m_Denominator == 1)
					return this.m_Numerator;
				else if (this.m_Denominator == 0)
				{
					switch (NormalizeIndeterminate(this.m_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.m_Numerator / (double)this.m_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.m_Denominator == 1)
				{
					return this.m_Numerator.ToString();
				}
				else if (this.m_Denominator == 0)
				{
					return IndeterminateTypeName(this.m_Numerator);
				}
				else
				{
					return this.m_Numerator.ToString() + "/" + this.m_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)
			{
				// it's one of the indeterminates... which?
				if (double.IsNaN(inValue))
					return NaN;
				else if (double.IsNegativeInfinity(inValue))
					return NegativeInfinity;
				else if (double.IsPositiveInfinity(inValue))
					return PositiveInfinity;
				else if (inValue == 0.0d)
					return Zero;
 
				if (inValue > Int64.MaxValue)
					throw new OverflowException(string.Format("Double {0} too large", inValue));
 
				if (inValue < -Int64.MaxValue)
					throw new OverflowException(string.Format("Double {0} too small", inValue));
 
				if (-EpsilonDouble < inValue && inValue < EpsilonDouble)
					throw new ArithmeticException(string.Format("Double {0} cannot be represented", inValue));
 
				int sign = Math.Sign(inValue);
				inValue = Math.Abs(inValue);
 
				return ConvertPositiveDouble(sign, 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</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 || 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?
						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.m_Denominator == 0 
					&& NormalizeIndeterminate(this.m_Numerator) == Indeterminates.NaN)
					return true;
				else
					return false;
			}
 
			/// <summary>
			/// Determines if a Fraction represents Any Infinity
			/// </summary>
			/// <returns>True if the Fraction is Positive Infinity or Negative Infinity</returns>
			public bool IsInfinity()
			{
				if (this.m_Denominator == 0
					&& NormalizeIndeterminate(this.m_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.m_Denominator == 0
					&& NormalizeIndeterminate(this.m_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.m_Denominator == 0
					&& NormalizeIndeterminate(this.m_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.m_Numerator = this.m_Denominator;
				frac.m_Denominator = this.m_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 Modulus operators
			public static Fraction operator %(Fraction left, Fraction right)
			{
				return Modulus(left, right);
			}
	    
			public static Fraction operator %(long left, Fraction right)
			{
				return Modulus(new Fraction(left), right);
			}
	    
			public static Fraction operator %(Fraction left, long right)
			{
				return Modulus(left, right);
			}
	    
			public static Fraction operator %(double left, Fraction right)
			{
				return Modulus(ToFraction(left), right);
			}
	    
			public static Fraction operator %(Fraction left, double right)
			{
				return Modulus(left, right);
			}
			#endregion
 
			#region Equal operators
			public static bool operator ==(Fraction left, Fraction right)
			{
				return left.CompareEquality(right, false);
			}
 
			public static bool operator ==(Fraction left, long right)
			{
				return left.CompareEquality(new Fraction(right), false);
			}
 
			public static bool operator ==(Fraction left, double right)
			{
				return left.CompareEquality(new Fraction(right), false);
			}
			#endregion
 
			#region Not-equal operators
			public static bool operator !=(Fraction left, Fraction right)
			{
				return left.CompareEquality(right, true);
			}
 
			public static bool operator !=(Fraction left, long right)
			{
				return left.CompareEquality(new Fraction(right), true);
			}
	        
			public static bool operator !=(Fraction left, double right)
			{
				return left.CompareEquality(new Fraction(right), true);
			}
			#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)
			{
				return left.CompareTo(right) < 0;
			}
 
			/// <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)
			{
				return left.CompareTo(right) > 0;
			}
 
			/// <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 left.CompareTo(right) <= 0;
			}
	        
			/// <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 left.CompareTo(right) >= 0;
			}
			#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  Fraction,</param>
			/// <returns>True if the value equals the current fraction, false otherwise (including for
			/// non-Fraction types or null object.</returns>
			public override bool Equals(object obj)
			{
				if (obj == null	|| ! (obj is Fraction))
					return false;
 
				try 
				{
					Fraction right = (Fraction)obj;
					return this.CompareEquality(right, false);
				}
				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);
 
				int numeratorHash = this.m_Numerator.GetHashCode();
				int denominatorHash = this.m_Denominator.GetHashCode();
 
				return (numeratorHash ^ denominatorHash);
			}
			#endregion
 
			#region IComparable member and type-specific version
			/// <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);
				}
			}
			#endregion
 
			#region IFormattable Members
			string System.IFormattable.ToString(string format, IFormatProvider formatProvider)
			{
				return this.m_Numerator.ToString(format, formatProvider) + "/" + this.m_Denominator.ToString(format, formatProvider);
			}
			#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.m_Denominator == 0)
				{
					frac.m_Numerator = (long)NormalizeIndeterminate(frac.m_Numerator);
					return;
				}
 
				// all forms of zero are alike.
				if (frac.m_Numerator == 0)
				{
					frac.m_Denominator = 1;
					return;
				}
	            
				long iGCD = GCD(frac.m_Numerator, frac.m_Denominator);
				frac.m_Numerator /= iGCD;
				frac.m_Denominator /= iGCD;
	        
				// if negative sign in denominator
				if ( frac.m_Denominator < 0 )
				{
					//move negative sign to numerator
					frac.m_Numerator = - frac.m_Numerator;
					frac.m_Denominator = - frac.m_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.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;
			}
			#endregion
 
			#region Implementation
			#region Convert a double to a fraction
			private static Fraction ConvertPositiveDouble(int sign, double inValue)
			{
				// Shamelessly stolen from http://homepage.smc.edu/kennedy_john/CONFRAC.PDF
				// with AccuracyFactor == double.Episilon
				long fractionNumerator = (long)inValue;
				double fractionDenominator = 1;
				double previousDenominator = 0;
				double remainingDigits = inValue;
				int maxIterations = 594;	// found at http://www.ozgrid.com/forum/archive/index.php/t-22530.html
 
				while (remainingDigits != Math.Floor(remainingDigits) 
					&& Math.Abs(inValue - (fractionNumerator / fractionDenominator)) > double.Epsilon)
				{
					remainingDigits = 1.0 / (remainingDigits - Math.Floor(remainingDigits));
 
					double scratch = fractionDenominator;
 
					fractionDenominator =(Math.Floor(remainingDigits) * fractionDenominator) + previousDenominator;
					fractionNumerator = (long)(inValue * fractionDenominator + 0.5);
 
					previousDenominator = scratch;
 
					if (maxIterations-- < 0)
						break;
				}
 
				return new Fraction(fractionNumerator * sign, (long)fractionDenominator);
			}
			#endregion
 
			#region Equality helper
			/// <summary>
			/// Compares for equality the current Fraction to the value passed.
			/// </summary>
			/// <param name="right">A Fraction to compare against</param>
			/// <param name="notEqualCheck">If true, we're looking for not-equal</param>
			/// <returns>True if the <paramref name="right"></paramref> equals the current 
			/// fraction, false otherwise. If comparing two NaNs, they are always equal AND
			/// not-equal.</returns>
			private bool CompareEquality(Fraction right, bool notEqualCheck)
			{
				// insure we're normalized first
				ReduceFraction(ref this);
 
				// now normalize the comperand
				ReduceFraction(ref right);
 
				if (this.m_Numerator == right.m_Numerator && this.m_Denominator == right.m_Denominator)
				{
					// special-case rule, two NaNs are always both equal
					if (notEqualCheck && this.IsNaN())
						return true;
					else
						return ! notEqualCheck;
				}
				else
				{
					return notEqualCheck;
				}
			}
			#endregion
 
			#region Comparison helper
			/// <summary>
			/// Determines how this Fraction, of an indeterminate type, compares to another Fraction
			/// </summary>
			/// <param name="leftType">What kind of indeterminate</param>
			/// <param name="right">The other 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>
			/// <remarks>NaN is less than anything except NaN and Negative Infinity. Negative Infinity is less
			/// than anything except Negative Infinity. Positive Infinity is greater than anything except
			/// Positive Infinity.</remarks>
			private static int IndeterminantCompare(Indeterminates leftType, Fraction right)
			{
				switch (leftType)
				{
					case Indeterminates.NaN:
						// A NaN is...
						if (right.IsNaN())
							return 0;	// equal to a NaN
						else if (right.IsNegativeInfinity())
							return 1;	// great than Negative Infinity
						else
							return -1;	// less than anything else
 
					case Indeterminates.NegativeInfinity:
						// Negative Infinity is...
						if (right.IsNegativeInfinity())
							return 0;	// equal to Negative Infinity
						else
							return -1;	// less than anything else
 
					case Indeterminates.PositiveInfinity:
						if (right.IsPositiveInfinity())
							return 0;	// equal to Positive Infinity
						else
							return 1;	// greater than anything else
 
					default:
						// this CAN'T happen, something VERY wrong is going on...
						return 0;
				}
			}
			#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)
			{
				// for a NaN, it's still a NaN
				return new Fraction( - frac.m_Numerator, frac.m_Denominator);
			}
 
			/// <summary>
			/// Adds two Fractions
			/// </summary>
			/// <param name="left">A Fraction</param>
			/// <param name="right">Another Fraction</param>
			/// <returns>Sum of the Fractions. Returns NaN if either Fraction is a NaN.</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)
			{
				if (left.IsNaN() || right.IsNaN())
					return NaN;
 
				long gcd = GCD(left.m_Denominator, right.m_Denominator); // cannot return less than 1
				long leftDenominator = left.m_Denominator / gcd;
				long rightDenominator = right.m_Denominator / gcd;
 
				try
				{
					checked
					{
						long numerator = left.m_Numerator * rightDenominator + right.m_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 NaN if either Fraction is a NaN.</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)
			{
				if (left.IsNaN() || right.IsNaN())
					return NaN;
 
				// 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
					{
						long numerator = left.m_Numerator * right.m_Numerator;
						long denominator = left.m_Denominator * right.m_Denominator;
 
						return new Fraction(numerator, denominator);
					}
				}
				catch (Exception e)
				{
					throw new FractionException("Multiply error", e);
				}
			}
 
			/// <summary>
			/// Returns the modulus (remainder after dividing) two Fractions
			/// </summary>
			/// <param name="left">A Fraction</param>
			/// <param name="right">Another Fraction</param>
			/// <returns>Modulus of the Fractions. Returns NaN if either Fraction is a NaN.</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 Modulus(Fraction left, Fraction right)
			{
				if (left.IsNaN() || right.IsNaN())
					return NaN;
 
				try
				{
					checked
					{
						// this will discard any fractional places...
						Int64 quotient = (Int64)(left / right);
						Fraction whole = new Fraction(quotient * right.m_Numerator, right.m_Denominator);
						return left - whole;
					}
				}
				catch (Exception e)
				{
					throw new FractionException("Modulus 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;
				}
			}
 
			// These are used to represent the indeterminate with a Denominator of zero
			private enum Indeterminates
			{
				NaN = 0
				, PositiveInfinity = 1
				, NegativeInfinity = -1
			}
			#endregion
 
			#region Member variables
			private long m_Numerator;
			private long m_Denominator;
			#endregion
			#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

Re: Some improvements for this class.

Hardy Wang

8:01 7 Mar '09

Very cool code. Just one comment, is it possible to add some fuzzy logic to convert something like 0.166666666667 into 1/6? Thanks! Hardy http://hardywang.spaces.live.com/ Hardy
Sign In·View Thread·Permalink

A few suggestions

Jeffrey Sax

17:19 16 Dec '04

Overall, this is a nice implementation of basic fraction functionality. There is still room for improvement, however:

Conversion from Double should use base 2 rather than base 10. The 'ToString()' causes loss of precision in several ways, most notably due to the fact that it uses only 15 digits of precision.

Every double value within the range of Fraction is exactly representable by a Fraction, and so you should make this conversion exact. A round-trip cast expression like (double)(Fraction)x should return the original value x, or throw an OverflowException if x is out of range.

Ideally, you would also offer to find the fraction closest to the number, using Euclid's GCD algorithm backwards. You could put an upper limit on the size of the denominator, so that, for example, 0.333333334 gets converted to 1/3 rather than 166666667/500000000.

Your addition method can cause overflow when that is not necessary. You should divide out any common factors of the denominators. This common factor will only be divided out in the normalization. You could do something like:

long gcd = GCD(frac1.Denominator, frac2.Denominator);
long denominator1 = frac1.Denominator / gcd;
long denominator2 = frac2.Denominator / gcd;
long iNumerator=frac1.Numerator*denominator2 + frac2.Numerator*denominator1;
long iDenominator=denominator1*denominator2*gcd;
return ( new Fraction(iNumerator, iDenominator) );

Similar improvements are possible for the other operators.

You may want to consider making this a value type (struct). The reasoning? We definitely have an object with value semantics here - it is just an alternate representation of a number. Moreover, it is small enough (16 bytes) so the by-value passing of value types shouldn't hinder performance.

It would also eliminate the need for methods like Duplicate and properties like Value, since you can use direct assignments.

Your implementation of Equals does not comply with the guidelines[^]. For example, your code throws an exception if the argument isn't of type Fraction. Equals should never throw an exception.

There may well be more. Improving code is like ironing out all the wrinkles: you get some of the bigger ones first, and then take care of the progressively smaller ones.

Nice work!

Jeffrey

Everything should be as simple as possible, but not simpler.
-- Albert Einstein
Numerical components for C# and VB.NET

Re: A few suggestions

Syed Mehroz Alam

20:54 20 Dec '04

Thank you for your valuable comments. I always need such comments to improve my programming skills. I admire your ideas and had it not been Marc there, I would have to re-write the code again. I thank you and Marc for your contribution to my class.

I agree with all of your suggestions except for one:
You have said to implement the class as a structure. The problem is that instance field members in a struct can not be initialized to any particular value and a fraction object having a denominator with 0 value is always a bad idea.

To illustrate my point, consider the following code

Struct Fraction
{
	// implemtation
}
public static void Main()
{
	Fraction frac=new Fraction();		// a fraction object initialized as 0/0
	Console.WriteLine( frac.ToString() )		// will display 0/0
	Console.WriteLine( frac.ToDouble().ToString() )	// will display NaN
	Frac+=1	// will throw an exception ( ZeroDeniminatorException)
}

Please do inform me if you have a solution to this problem.

Thanks,
Syed Mehroz Alam
Email: smehrozalam@yahoo.com
Homepage: Programming Home
URL: http://www.geocities.com/smehrozalam/

Re: A few suggestions

Jeffrey Sax

22:45 20 Dec '04

Hi Syed,

Syed Mehroz Alam wrote:
You have said to implement the class as a structure. The problem is that instance field members in a struct can not be initialized to any particular value and a fraction object having a denominator with 0 value is always a bad idea.

You make a very good point. It is a strong recommendation that value types should have their natural, default value when uninitialized (or created using the default constructor). For fractions, this value would be 0.

However, I don't see too much wrong with implementing 0 as a special value, and giving it special treatment where required. Most operations would benefit from such special treatment anyway. I feel it would be perfectly acceptable to have the value of zero represented internally as "0/0", especially if you also implement the other special values (NaNs and infinities), as Marc did. The internal representation is not important for the users of your type.

As a 'justification,' you may be interested to know that the value of zero is a special value for the standard floating-point types as well. Floating-point numbers can be written as a sign times a value between 1 and 2 (the significand) times a power of two. Because the leading bit of the significand is always 1, it is implied and not explicitly set in the floating-point formats. This means, however, that the value of zero cannot be treated as most other numbers, because the 'leading' bit of the significand is zero.

Jeffrey

Everything should be as simple as possible, but not simpler.
-- Albert Einstein
Numerical components for C# and VB.NET