Algorithm for simplifying decimal to fractions

The algorithm that the other people have given you gets the answer by calculating the Continued Fraction of the number. This gives a fractional sequence which is guaranteed to converge very, very rapidly. However it is not guaranteed to give you the smallest fraction that is within a distance epsilon of a real number. To find that you have to walk the Stern-Brocot tree.

To do that you subtract off the floor to get the number in the range [0, 1), then your lower estimate is 0, and your upper estimate is 1. Now do a binary search until you are close enough. At each iteration if your lower is a/b and your upper is c/d your middle is (a+c)/(b+d). Test your middle against x, and either make the middle the upper, the lower, or return your final answer.

Here is some very non-idiomatic (and hence, hopefully, readable even if you don't know the language) Python that implements this algorithm.

def float_to_fraction (x, error=0.000001):
    n = int(math.floor(x))
    x -= n
    if x < error:
        return (n, 1)
    elif 1 - error < x:
        return (n+1, 1)

    # The lower fraction is 0/1
    lower_n = 0
    lower_d = 1
    # The upper fraction is 1/1
    upper_n = 1
    upper_d = 1
    while True:
        # The middle fraction is (lower_n + upper_n) / (lower_d + upper_d)
        middle_n = lower_n + upper_n
        middle_d = lower_d + upper_d
        # If x + error < middle
        if middle_d * (x + error) < middle_n:
            # middle is our new upper
            upper_n = middle_n
            upper_d = middle_d
        # Else If middle < x - error
        elif middle_n < (x - error) * middle_d:
            # middle is our new lower
            lower_n = middle_n
            lower_d = middle_d
        # Else middle is our best fraction
        else:
            return (n * middle_d + middle_n, middle_d)

I know you said you searched online, but if you missed the following paper it might be of some help. It includes a code example in Pascal.

Algorithm To Convert A Decimal To A Fraction^*

Alternatively, as part of it's standard library, Ruby has code that deals with rational numbers. It can convert from floats to rationals and vice versa. I believe you can look through the code as well. The documentation is found here. I know you're not using Ruby, but it might help to look at the algorithms.

Additionally, you can call Ruby code from C# (or even write Ruby code inside a C# code file) if you use IronRuby, which runs on top of the .net framework.

*_{Updated to a new link using http://www.docstoc.com/ as it appears the original URL is no broken (http://homepage.smc.edu/kennedy_john/DEC2FRAC.pdf)}

I found the same paper that Matt referenced, and I took a second and implemented it in Python. Maybe seeing the same idea in code will make it clearer. Granted, you requested an answer in C# and I'm giving it to you in Python, but it's a fairly trivial program, and I'm sure it would be easy to translate. The parameters are num (the decimal number you'd like to convert to a rational) and epsilon (the maximum allowed difference between num and the calculated rational). Some quick test runs find that it usually only takes two or three iterations to converge when epsilon is around 1e-4.

def dec2frac(num, epsilon, max_iter=20):
    d = [0, 1] + ([0] * max_iter)
    z = num
    n = 1
    t = 1

    while num and t < max_iter and abs(n/d[t] - num) > epsilon:
        t += 1
        z = 1/(z - int(z))
        d[t] = d[t-1] * int(z) + d[t-2]
        # int(x + 0.5) is equivalent to rounding x.
        n = int(num * d[t] + 0.5)

    return n, d[t]

Edit: I just noticed your note about wanting them to work with recurring decimals. I don't know any languages that have syntax to support recurring decimals, so I'm not sure how one would go about handling them, but running 0.6666666 and 0.166666 through this method return the correct results (2/3 and 1/6, respectively).

Another Edit (I didn't think this would be so interesting!): If you want to know more about the theory behind this algorithm, Wikipedia has an excellent page on the Euclidian algorithm

Here's a C# version of Will Brown's python example. I've also changed it to handle separate whole numbers (e.g. "2 1/8" instead of "17/8").

    public static string DoubleToFraction(double num, double epsilon = 0.0001, int maxIterations = 20)
    {
        double[] d = new double[maxIterations + 2];
        d[1] = 1;
        double z = num;
        double n = 1;
        int t = 1;

        int wholeNumberPart = (int)num;
        double decimalNumberPart = num - Convert.ToDouble(wholeNumberPart);

        while (t < maxIterations && Math.Abs(n / d[t] - num) > epsilon)
        {
            t++;
            z = 1 / (z - (int)z);
            d[t] = d[t - 1] * (int)z + d[t - 2];
            n = (int)(decimalNumberPart * d[t] + 0.5);
        }

        return string.Format((wholeNumberPart > 0 ? wholeNumberPart.ToString() + " " : "") + "{0}/{1}",
                             n.ToString(),
                             d[t].ToString()
                            );
    }

You can't represent a recurring decimal in .net so I'll ignore that part of your question.

You can only represent a finite and relatively small number of digits.

There's an extremely simple algorithm:

• take decimal x
• count the number of digits after the decimal point; call this n
• create a fraction (10^n * x) / 10^n
• remove common factors from the numerator and denominator.

so if you have 0.44, you would count 2 places are the decimal point - n = 2, and then write

• (0.44 * 10^2) / 10^2
• = 44 / 100
• factorising (removing common factor of 4) gives 11 / 25

I wrote a quick class that runs fairly quick and gives the results I would expect. You can choose your Precision as well. It is much simpler from any code I seen and runs quick as well.

//Written By Brian Dobony
public static class Fraction
{
    public static string ConvertDecimal(Double NumberToConvert, int DenominatorPercision = 32)
    {
        int WholeNumber = (int)NumberToConvert;
        double DecimalValue = NumberToConvert - WholeNumber;

        double difference = 1;
        int numerator = 1;
        int denominator = 1;

        // find closest value that matches percision
        // Automatically finds Fraction in simplified form
        for (int y = 2; y < DenominatorPercision + 1; y++)
        {
                for (int x = 1; x < y; x++)
                {
                    double tempdif = Math.Abs(DecimalValue - (double)x / (double)y);
                    if (tempdif < difference)
                    {
                        numerator = x;
                        denominator = y;
                        difference = tempdif;
                        // if exact match is found return it
                        if (difference == 0)
                        {
                            return FractionBuilder(WholeNumber, numerator, denominator);
                        }
                    }
                }
        }
        return FractionBuilder(WholeNumber, numerator, denominator);
    }

    private static string FractionBuilder(int WholeNumber, int Numerator, int Denominator)
    {
        if (WholeNumber == 0)
        {
            return Numerator + @"/" + Denominator;
        }
        else
        {
            return WholeNumber + " " + Numerator + @"/" + Denominator;
        }
    }
}

A recurring decimal can be represented by two finite decimals: the leftward part before the repeat, and the repeating part. E.g. 1.6181818... = 1.6 + 0.1*(0.18...). Think of this as a + b * sum(c * 10**-(d*k) for k in range(1, infinity)) (in Python notation here). In my example, a=1.6, b=0.1, c=18, d=2 (the number of digits in c). The infinite sum can be simplified (sum(r**k for r in range(1, infinity)) == r / (1 - r) if I recall rightly), yielding a + b * (c * 10**-d) / (1 - c * 10**-d)), a finite ratio. That is, start with a, b, c, and d as rational numbers, and you end up with another.

(This elaborates Kirk Broadhurst's answer, which is right as far as it goes, but doesn't cover repeating decimals. I don't promise I made no mistakes above, though I'm confident the general approach works.)

I recently had to perform this very task of working with a Decimal Data Type which is stored in our SQL Server database. At the Presentation Layer this value was edited as a fractional value in a TextBox. The complexity here was working with the Decimal Data Type which holds some pretty large values in comparison to int or long. So to reduce the opportunity for data overrun, I stuck with the Decimal Data Type throughout the conversion.

Before I begin, I want to comment on Kirk's previous answer. He is absolutely correct as long as there are no assumptions made. However, if the developer only looks for repeating patterns within the confines of the Decimal Data Type .3333333... can be represented as 1/3. An example of the algorithm can be found at basic-mathematics.com. Again, this means you have to make assumptions based on the information available and using this method only captures a very small subset of repeating decimals. However for small numbers should be okay.

Moving forward, let me give you a snapshot of my solution. If you want to read a complete example with additional code I created a blog post with much more detail.

Convert Decimal Data Type to a String Fraction

public static void DecimalToFraction(decimal value, ref decimal sign, ref decimal numerator, ref decimal denominator)
{
    const decimal maxValue = decimal.MaxValue / 10.0M;

    // e.g. .25/1 = (.25 * 100)/(1 * 100) = 25/100 = 1/4
    var tmpSign = value < decimal.Zero ? -1 : 1;
    var tmpNumerator = Math.Abs(value);
    var tmpDenominator = decimal.One;

    // While numerator has a decimal value
    while ((tmpNumerator - Math.Truncate(tmpNumerator)) > 0 && 
        tmpNumerator < maxValue && tmpDenominator < maxValue)
    {
        tmpNumerator = tmpNumerator * 10;
        tmpDenominator = tmpDenominator * 10;
    }

    tmpNumerator = Math.Truncate(tmpNumerator); // Just in case maxValue boundary was reached.
    ReduceFraction(ref tmpNumerator, ref tmpDenominator);
    sign = tmpSign;
    numerator = tmpNumerator;
    denominator = tmpDenominator;
}

public static string DecimalToFraction(decimal value)
{
    var sign = decimal.One;
    var numerator = decimal.One;
    var denominator = decimal.One;
    DecimalToFraction(value, ref sign, ref numerator, ref denominator);
    return string.Format("{0}/{1}", (sign * numerator).ToString().TruncateDecimal(), 
        denominator.ToString().TruncateDecimal());
}

This is pretty straight forward where the DecimalToFraction(decimal value) is nothing more than a simplified entry point for the first method which provides access to all the components which compose a fraction. If you have a decimal of .325 then divide it by 10 to the power of number of decimal places. Lastly reduce the fraction. And, in this example .325 = 325/10^3 = 325/1000 = 13/40.

Next, going the other direction.

Convert String Fraction to Decimal Data Type

static readonly Regex FractionalExpression = new Regex(@"^(?<sign>[-])?(?<numerator>\d+)(/(?<denominator>\d+))?$");
public static decimal? FractionToDecimal(string fraction)
{
    var match = FractionalExpression.Match(fraction);
    if (match.Success)
    {
        // var sign = Int32.Parse(match.Groups["sign"].Value + "1");
        var numerator = Int32.Parse(match.Groups["sign"].Value + match.Groups["numerator"].Value);
        int denominator;
        if (Int32.TryParse(match.Groups["denominator"].Value, out denominator))
            return denominator == 0 ? (decimal?)null : (decimal)numerator / denominator;
        if (numerator == 0 || numerator == 1)
            return numerator;
    }
    return null;
}

Converting back to a decimal is quite simple as well. Here we parse out the fractional components, store them in something we can work with (here decimal values) and perform our division.

My 2 cents. Here's VB.NET version of btilly's excellent algorithm:

   Public Shared Sub float_to_fraction(x As Decimal, ByRef Numerator As Long, ByRef Denom As Long, Optional ErrMargin As Decimal = 0.001)
    Dim n As Long = Int(Math.Floor(x))
    x -= n

    If x < ErrMargin Then
        Numerator = n
        Denom = 1
        Return
    ElseIf x >= 1 - ErrMargin Then
        Numerator = n + 1
        Denom = 1
        Return
    End If

    ' The lower fraction is 0/1
    Dim lower_n As Integer = 0
    Dim lower_d As Integer = 1
    ' The upper fraction is 1/1
    Dim upper_n As Integer = 1
    Dim upper_d As Integer = 1

    Dim middle_n, middle_d As Decimal
    While True
        ' The middle fraction is (lower_n + upper_n) / (lower_d + upper_d)
        middle_n = lower_n + upper_n
        middle_d = lower_d + upper_d
        ' If x + error < middle
        If middle_d * (x + ErrMargin) < middle_n Then
            ' middle is our new upper
            upper_n = middle_n
            upper_d = middle_d
            ' Else If middle < x - error
        ElseIf middle_n < (x - ErrMargin) * middle_d Then
            ' middle is our new lower
            lower_n = middle_n
            lower_d = middle_d
            ' Else middle is our best fraction
        Else
            Numerator = n * middle_d + middle_n
            Denom = middle_d
            Return
        End If
    End While
End Sub

This algorithm by David Eppstein, UC Irvine, based on the theory of continued fractions and originally in C, was translated to C# by me. The fractions it generates satisfy the error margin but mostly do not look as good as the solution in my other answer. E.g. 0.5 becomes 999/1999 while 1/2 would be preferred when displayed to a user (if you need that, see my other answer).

It is definitely fast though.

There is an overload to specify the error margin as a double (relative to the value, not the absolute error). For the Fraction type, see my other answer.

By the way, if your fractions can get large, change the ints to long.

public static Fraction RealToFraction(double value, int maxDenominator)
{
    // http://www.ics.uci.edu/~eppstein/numth/frap.c
    // Find rational approximation to given real number
    // David Eppstein / UC Irvine / 8 Aug 1993
    // With corrections from Arno Formella, May 2008

    if (value == 0.0)
    {
        return new Fraction(0, 1);
    }

    int sign = Math.Sign(value);

    if (sign == -1)
    {
        value = Math.Abs(value);
    }

    int[,] m = { { 1, 0 }, { 0, 1 } };
    int ai = (int) value;

    // Find terms until denominator gets too big
    while (m[1, 0] * ai + m[1, 1] <= maxDenominator)
    {
        int t = m[0, 0] * ai + m[0, 1];
        m[0, 1] = m[0, 0];
        m[0, 0] = t;
        t = m[1, 0] * ai + m[1, 1];
        m[1, 1] = m[1, 0];
        m[1, 0] = t;

        value = 1.0 / (value - ai);

        // 0x7FFFFFFF = Assumes 32 bit floating point just like in the C implementation.
        // This check includes Double.IsInfinity(). Even though C# double is 64 bits,
        // the algorithm sometimes fails when trying to increase this value too much. So
        // I kept it. Anyway, it works.
        if (value > 0x7FFFFFFF)
        {                    
            break;
        }

        ai = (int) value;
    }

    // Two approximations are calculated: one on each side of the input
    // The result of the first one is the current value. Below the other one
    // is calculated and it is returned.

    ai = (maxDenominator - m[1, 1]) / m[1, 0];
    m[0, 0] = m[0, 0] * ai + m[0, 1];
    m[1, 0] = m[1, 0] * ai + m[1, 1];

    return new Fraction(sign * m[0, 0], m[1, 0]);
}

public static Fraction RealToFraction(double value, double error)
{
    if (error <= 0.0 || error >= 1)
    {
        throw new ArgumentOutOfRangeException("error", "Must be between 0 and 1 (exclusive).");
    }

    int maxDenominator = (int) Math.Ceiling(Math.Abs(1.0 / (value * error)));

    if (maxDenominator < 1)
    {
        maxDenominator = 1;
    }

    return RealToFraction(value, maxDenominator);
}

Test results:

// error = 0.001

                 0   ->   0/1 (zero) 0 (0 iterations)
               0.1   ->   999/9991 -0.01% (2 iterations)
               0.2   ->   999/4996 -0.02% (2 iterations)
               0.3   ->   998/3327 -0.01% (4 iterations)
               0.4   ->   999/2497 0.02% (3 iterations)
               0.5   ->   999/1999 -0.05% (2 iterations)
               0.6   ->   1000/1667 -0.02% (4 iterations)
               0.7   ->   996/1423 -0.01% (4 iterations)
               0.8   ->   997/1246 0.02% (3 iterations)
               0.9   ->   998/1109 -0.01% (4 iterations)
              0.01   ->   999/99901 0.00% (2 iterations)
             0.001   ->   999/999001 0.00% (2 iterations)
            0.0001   ->   999/9990001 0.00% (2 iterations)
           0.00001   ->   1000/99999999 0.00% (3 iterations)
     0.33333333333   ->   1000/3001 -0.03% (2 iterations)
               0.3   ->   998/3327 -0.01% (4 iterations)
              0.33   ->   991/3003 0.00% (3 iterations)
             0.333   ->   1000/3003 0.00% (3 iterations)
            0.7777   ->   997/1282 0.00% (4 iterations)
             0.101   ->   919/9099 0.00% (5 iterations)
           0.10001   ->   1/10 -0.01% (4 iterations)
       0.100000001   ->   1000/9999 0.01% (3 iterations)
          0.001001   ->   1/999 0.00% (3 iterations)
      0.0010000001   ->   1000/999999 0.00% (3 iterations)
              0.11   ->   1000/9091 0.00% (4 iterations)
            0.1111   ->   1000/9001 0.00% (2 iterations)
    0.111111111111   ->   1000/9001 -0.01% (2 iterations)
                 1   ->   1001/1000 0.10% (1 iterations)
                -1   ->   -1001/1000 0.10% (1 iterations)
              -0.5   ->   -999/1999 -0.05% (2 iterations)
              3.14   ->   964/307 0.00% (3 iterations)
            3.1416   ->   732/233 0.00% (3 iterations)
  3.14159265358979   ->   688/219 0.00% (4 iterations)
              0.14   ->   995/7107 0.00% (3 iterations)
            0.1416   ->   869/6137 0.00% (5 iterations)
 0.141592653589793   ->   991/6999 0.00% (4 iterations)
 -1.33333333333333   ->   -1001/751 -0.03% (2 iterations)
              -1.3   ->   -992/763 0.01% (3 iterations)
             -1.33   ->   -935/703 0.00% (3 iterations)
            -1.333   ->   -1001/751 -0.01% (2 iterations)
       -1.33333337   ->   -999/749 0.03% (3 iterations)
              -1.7   ->   -991/583 -0.01% (4 iterations)
             -1.37   ->   -996/727 0.00% (7 iterations)
          -1.33337   ->   -999/749 0.03% (3 iterations)
          0.047619   ->   1000/21001 0.00% (2 iterations)
            12.125   ->   982/81 -0.01% (2 iterations)
   0.1233333333333   ->   971/7873 0.00% (4 iterations)
   0.7454545454545   ->   981/1316 0.00% (6 iterations)
     0.01024801004   ->   488/47619 0.00% (13 iterations)
           0.99011   ->   801/809 0.00% (5 iterations)
      0.9901134545   ->   601/607 0.00% (5 iterations)
        0.19999999   ->   1000/5001 -0.02% (2 iterations)
        0.20000001   ->   1000/4999 0.02% (3 iterations)
 0.000050183168565   ->   999/19907074 0.00% (2 iterations)
      88900003.001   ->   88900004/1 0.00% (1 iterations)

// error = 0.1

                 0   ->   0/1 (zero) 0 (0 iterations)
               0.1   ->   9/91 -1.10% (2 iterations)
               0.2   ->   9/46 -2.17% (2 iterations)
               0.3   ->   8/27 -1.23% (4 iterations)
               0.4   ->   9/22 2.27% (3 iterations)
               0.5   ->   9/19 -5.26% (2 iterations)
               0.6   ->   10/17 -1.96% (4 iterations)
               0.7   ->   9/13 -1.10% (4 iterations)
               0.8   ->   9/11 2.27% (3 iterations)
               0.9   ->   8/9 -1.23% (4 iterations)
              0.01   ->   9/901 -0.11% (2 iterations)
             0.001   ->   9/9001 -0.01% (2 iterations)
            0.0001   ->   9/90001 0.00% (2 iterations)
           0.00001   ->   10/999999 0.00% (3 iterations)
     0.33333333333   ->   10/31 -3.23% (2 iterations)
               0.3   ->   8/27 -1.23% (4 iterations)
              0.33   ->   10/31 -2.25% (2 iterations)
             0.333   ->   10/31 -3.13% (2 iterations)
            0.7777   ->   10/13 -1.09% (4 iterations)
             0.101   ->   1/10 -0.99% (4 iterations)
           0.10001   ->   10/99 1.00% (3 iterations)
       0.100000001   ->   10/99 1.01% (3 iterations)
          0.001001   ->   10/9991 -0.01% (2 iterations)
      0.0010000001   ->   10/9999 0.01% (3 iterations)
              0.11   ->   1/9 1.01% (3 iterations)
            0.1111   ->   10/91 -1.09% (2 iterations)
    0.111111111111   ->   10/91 -1.10% (2 iterations)
                 1   ->   11/10 10.00% (1 iterations)
                -1   ->   -11/10 10.00% (1 iterations)
              -0.5   ->   -9/19 -5.26% (2 iterations)
              3.14   ->   13/4 3.50% (1 iterations)
            3.1416   ->   13/4 3.45% (1 iterations)
  3.14159265358979   ->   13/4 3.45% (1 iterations)
              0.14   ->   8/57 0.25% (3 iterations)
            0.1416   ->   10/71 -0.53% (2 iterations)
 0.141592653589793   ->   10/71 -0.53% (2 iterations)
 -1.33333333333333   ->   -9/7 -3.57% (2 iterations)
              -1.3   ->   -9/7 -1.10% (2 iterations)
             -1.33   ->   -9/7 -3.33% (2 iterations)
            -1.333   ->   -9/7 -3.55% (2 iterations)
       -1.33333337   ->   -11/8 3.12% (3 iterations)
              -1.7   ->   -7/4 2.94% (3 iterations)
             -1.37   ->   -4/3 -2.68% (4 iterations)
          -1.33337   ->   -11/8 3.12% (3 iterations)
          0.047619   ->   10/211 -0.47% (2 iterations)
            12.125   ->   13/1 7.22% (1 iterations)
   0.1233333333333   ->   10/81 0.10% (3 iterations)
   0.7454545454545   ->   8/11 -2.44% (4 iterations)
     0.01024801004   ->   5/488 -0.02% (6 iterations)
           0.99011   ->   10/11 -8.18% (2 iterations)
      0.9901134545   ->   10/11 -8.18% (2 iterations)
        0.19999999   ->   10/51 -1.96% (2 iterations)
        0.20000001   ->   10/49 2.04% (3 iterations)
 0.000050183168565   ->   9/179344 0.00% (2 iterations)
      88900003.001   ->   88900004/1 0.00% (1 iterations)

I implemented btilly's answer in C# and added support for negative numbers. Double.NaN and Double.Infinity are not supported; you might want to handle those too (example).

public static Fraction RealToFraction(double value, double error)
{
    if (error <= 0.0 || error >= 1.0)
    {
        throw new ArgumentOutOfRangeException("error", "Must be between 0 and 1 (exclusive).");
    }

    int sign = Math.Sign(value);

    if (sign == -1)
    {
        value = Math.Abs(value);
    }

    if (sign != 0)
    {
        error *= value;
    }

    int n = (int) Math.Floor(value);
    value -= n;

    if (value < error)
    {
        return new Fraction(sign * n, 1);
    }

    if (1 - error < value)
    {
        return new Fraction(sign * (n + 1), 1);
    }

    // The lower fraction is 0/1
    int lower_n = 0;
    int lower_d = 1;

    // The upper fraction is 1/1
    int upper_n = 1;
    int upper_d = 1;

    while (true)
    {
        // The middle fraction is (lower_n + upper_n) / (lower_d + upper_d)
        int middle_n = lower_n + upper_n;
        int middle_d = lower_d + upper_d;

        if (middle_d * (value + error) < middle_n)
        {
            // real + error < middle : middle is our new upper
            upper_n = middle_n;
            upper_d = middle_d;
        }
        else if (middle_n < (value - error) * middle_d)
        {
            // middle < real - error : middle is our new lower
            lower_n = middle_n;
            lower_d = middle_d;
        }
        else
        {
            // Middle is our best fraction
            return new Fraction((n * middle_d + middle_n) * sign, middle_d);
        }
    }
}

The Fraction type is just a simple struct. Of course, use your own preferred type... (I like this one by Rick Davin.)

public struct Fraction
{
    public Fraction(int n, int d)
    {
        N = n;
        D = d;
    }

    public int N { get; private set; }
    public int D { get; private set; }
}

I tested RealToFraction() with the following results:

// error = 0.001

                 0   ->   0/1 (zero) 0.00 (0 iterations)
               0.1   ->   1/10 0.00% (9 iterations)
               0.2   ->   1/5 0.00% (4 iterations)
               0.3   ->   3/10 0.00% (5 iterations)
               0.4   ->   2/5 0.00% (3 iterations)
               0.5   ->   1/2 0.00% (1 iterations)
               0.6   ->   3/5 0.00% (3 iterations)
               0.7   ->   7/10 0.00% (5 iterations)
               0.8   ->   4/5 0.00% (4 iterations)
               0.9   ->   9/10 0.00% (9 iterations)
              0.01   ->   1/100 0.00% (99 iterations)
             0.001   ->   1/1000 0.00% (999 iterations)
            0.0001   ->   1/9991 0.09% (9990 iterations)
           0.00001   ->   1/99901 0.10% (99900 iterations)
     0.33333333333   ->   1/3 0.00% (2 iterations)
               0.3   ->   3/10 0.00% (5 iterations)
              0.33   ->   30/91 -0.10% (32 iterations)
             0.333   ->   167/502 -0.10% (169 iterations)
            0.7777   ->   7/9 0.01% (5 iterations)
             0.101   ->   10/99 0.01% (18 iterations)
           0.10001   ->   1/10 -0.01% (9 iterations)
       0.100000001   ->   1/10 0.00% (9 iterations)
          0.001001   ->   1/999 0.00% (998 iterations)
      0.0010000001   ->   1/1000 0.00% (999 iterations)
              0.11   ->   10/91 -0.10% (18 iterations)
            0.1111   ->   1/9 0.01% (8 iterations)
    0.111111111111   ->   1/9 0.00% (8 iterations)
                 1   ->   1/1 0.00% (0 iterations)
                -1   ->   -1/1 0.00% (0 iterations)
              -0.5   ->   -1/2 0.00% (1 iterations)
              3.14   ->   22/7 0.09% (6 iterations)
            3.1416   ->   22/7 0.04% (6 iterations)
  3.14159265358979   ->   22/7 0.04% (6 iterations)
              0.14   ->   7/50 0.00% (13 iterations)
            0.1416   ->   15/106 -0.06% (21 iterations)
 0.141592653589793   ->   15/106 -0.06% (21 iterations)
 -1.33333333333333   ->   -4/3 0.00% (2 iterations)
              -1.3   ->   -13/10 0.00% (5 iterations)
             -1.33   ->   -97/73 -0.09% (26 iterations)
            -1.333   ->   -4/3 0.03% (2 iterations)
       -1.33333337   ->   -4/3 0.00% (2 iterations)
              -1.7   ->   -17/10 0.00% (5 iterations)
             -1.37   ->   -37/27 0.03% (7 iterations)
          -1.33337   ->   -4/3 0.00% (2 iterations)
          0.047619   ->   1/21 0.00% (20 iterations)
            12.125   ->   97/8 0.00% (7 iterations)
   0.1233333333333   ->   9/73 -0.04% (16 iterations)
   0.7454545454545   ->   38/51 -0.05% (15 iterations)
     0.01024801004   ->   2/195 0.08% (98 iterations)
           0.99011   ->   91/92 -0.10% (91 iterations)
      0.9901134545   ->   91/92 -0.10% (91 iterations)
        0.19999999   ->   1/5 0.00% (4 iterations)
        0.20000001   ->   1/5 0.00% (4 iterations)
 0.000050183168565   ->   1/19908 0.10% (19907 iterations)
      88900003.001   ->   88900003/1 0.00% (0 iterations)

// error = 0.1

                 0   ->   0/1 (zero) 0.00 (0 iterations)
               0.1   ->   1/10 0.00% (9 iterations)
               0.2   ->   1/5 0.00% (4 iterations)
               0.3   ->   2/7 -4.76% (4 iterations)
               0.4   ->   2/5 0.00% (3 iterations)
               0.5   ->   1/2 0.00% (1 iterations)
               0.6   ->   3/5 0.00% (3 iterations)
               0.7   ->   2/3 -4.76% (2 iterations)
               0.8   ->   3/4 -6.25% (3 iterations)
               0.9   ->   5/6 -7.41% (5 iterations)
              0.01   ->   1/91 9.89% (90 iterations)
             0.001   ->   1/910 9.89% (909 iterations)
            0.0001   ->   1/9091 10.00% (9090 iterations)
           0.00001   ->   1/90910 10.00% (90909 iterations)
     0.33333333333   ->   1/3 0.00% (2 iterations)
               0.3   ->   2/7 -4.76% (4 iterations)
              0.33   ->   1/3 1.01% (2 iterations)
             0.333   ->   1/3 0.10% (2 iterations)
            0.7777   ->   3/4 -3.56% (3 iterations)
             0.101   ->   1/10 -0.99% (9 iterations)
           0.10001   ->   1/10 -0.01% (9 iterations)
       0.100000001   ->   1/10 0.00% (9 iterations)
          0.001001   ->   1/909 9.90% (908 iterations)
      0.0010000001   ->   1/910 9.89% (909 iterations)
              0.11   ->   1/9 1.01% (8 iterations)
            0.1111   ->   1/9 0.01% (8 iterations)
    0.111111111111   ->   1/9 0.00% (8 iterations)
                 1   ->   1/1 0.00% (0 iterations)
                -1   ->   -1/1 0.00% (0 iterations)
              -0.5   ->   -1/2 0.00% (1 iterations)
              3.14   ->   3/1 -4.46% (0 iterations)
            3.1416   ->   3/1 -4.51% (0 iterations)
  3.14159265358979   ->   3/1 -4.51% (0 iterations)
              0.14   ->   1/7 2.04% (6 iterations)
            0.1416   ->   1/7 0.89% (6 iterations)
 0.141592653589793   ->   1/7 0.89% (6 iterations)
 -1.33333333333333   ->   -4/3 0.00% (2 iterations)
              -1.3   ->   -4/3 2.56% (2 iterations)
             -1.33   ->   -4/3 0.25% (2 iterations)
            -1.333   ->   -4/3 0.03% (2 iterations)
       -1.33333337   ->   -4/3 0.00% (2 iterations)
              -1.7   ->   -5/3 -1.96% (2 iterations)
             -1.37   ->   -3/2 9.49% (1 iterations)
          -1.33337   ->   -4/3 0.00% (2 iterations)
          0.047619   ->   1/20 5.00% (19 iterations)
            12.125   ->   12/1 -1.03% (0 iterations)
   0.1233333333333   ->   1/8 1.35% (7 iterations)
   0.7454545454545   ->   3/4 0.61% (3 iterations)
     0.01024801004   ->   1/89 9.64% (88 iterations)
           0.99011   ->   1/1 1.00% (0 iterations)
      0.9901134545   ->   1/1 1.00% (0 iterations)
        0.19999999   ->   1/5 0.00% (4 iterations)
        0.20000001   ->   1/5 0.00% (4 iterations)
 0.000050183168565   ->   1/18116 10.00% (18115 iterations)
      88900003.001   ->   88900003/1 0.00% (0 iterations)

As you can see, values near 1e-n (0.1, 0.01, 0.001, etc.) always result in extreme numbers of iterations. Some randomly entered numbers like the 0.01024801004 too (88 iterations even while error = 0.1, i.e. not requiring a high precision). Stopping at a certain maximum iteration number does not solve this: the error % would be high. I think if you encounter this often in time critical code you could add caching with a dictionary. Well, only if these exact same values return often, of course.

Another solution would be to, as soon as the number of iterations reaches a certain amount, like 10 or 20, abort and call another algorithm. Actually the algorithm in my other answer is a lot faster.

By the way, if your fractions can get large, change the ints to long.

Here's an algorithm implemented in VB that converts Floating Point Decimal to Integer Fraction that I wrote many years ago.

Basically you start with a numerator = 0 and a denominator = 1, then if the quotient is less than the decimal input, add 1 to the numerator and if the quotient is greater than the decimal input, add 1 to the denominator. Repeat until you get within your desired precision.

If I were you I'd handle the "no repeating decimals in .NET" problem by having it convert strings with the recurrence marked somehow.

E.g. 1/3 could be represented "0.R3" 1/60 could be represented "0.01R6"

I'd require an explicit cast from double or decimal because such values could only be converted into a fraction that was close. Implicit cast from int is ok.

You could use a struct and store your fraction (f) in two longs p and q such that f=p/q, q!=0, and gcd(p, q) == 1.