Decimals not converting to correct fractions

[Jennifer Sohl]

Hi. Awhile back, I found a class that takes a decimal value and converts it to a fraction. It seemed to have been working OK, but a couple of users noticed some decimal values not converting properly.
The two they've noticed so far are :
.781 should convert to 25/32, but it's converting to 7/9.
.625 should convert to 3/8, but it's converting to 3/5.
I tried to look at the code and figure out what was going on, but I guess I really don't understand everything that is going on to get fraction values.
Could someone take a look at the method that is supposed to be converting the value to a fraction, and help me understand why it is doing it?
Here's the method: (Sorry it's so long)

public String getFractionFormatOfDecimal(String value)  {
String whole = null;
String mantissa = null;
String fraction = "";
String result = null;
//  Separate the parts of the String decimal value.
int decimalpt = value.indexOf(".");
if (decimalpt == -1) {
whole = value;
}
else {
whole = value.substring(0, decimalpt);
mantissa = value.substring(decimalpt);
mantissa = "0"+mantissa;
}
//  If there is a mantissa, get its String fraction value.
if (mantissa != null) {
Double doubleMantissa = new Double(mantissa);
double decimal = doubleMantissa.doubleValue();
// In BMMASTR values are rounded off. Need to get the
// actual decimal value in order to get proper fraction value.
if(decimal == .062) {
decimal = .0625;
}
else if(decimal == .031) {
decimal = .03125;
}
else if(decimal == .015) {
decimal = .015625;
}
else if(decimal == .046) {
decimal = .046875;
}
else if(decimal == .078) {
decimal = .078125;
}
else if(decimal == .093) {
decimal = .09375;
}
else if(decimal == .140) {
decimal = .140625;
}
else if(decimal == .156) {
decimal = .15625;
}
else if(decimal == .171) {
decimal = .171;
}
else if(decimal == .187) {
decimal = .1875;
}
else if(decimal == .203) {
decimal = .203125;
}
else if(decimal == .218) {
decimal = .21875;
}
else if(decimal == 234) {
decimal = .234375;
}
else if(decimal == .265) {
decimal = .265625;
}
else if(decimal == .281) {
decimal = .28125;
}
else if(decimal == .296) {
decimal = .296875;
}
else if(decimal == .312) {
decimal = .3125;
}
else if(decimal == .328) {
decimal = .328125;
}
else if(decimal == .343) {
decimal = .34375;
}
else if(decimal == .359) {
decimal = .359375;
}
else if(decimal == .390) {
decimal = .390625;
}
else if(decimal == .406) {
decimal = .40625;
}
else if(decimal == .421) {
decimal = .421875;
}
else if(decimal == .437) {
decimal = .4375;
}
else if(decimal == .453) {
decimal = .453125;
}
else if(decimal == .468) {
decimal = .46875;
}
else if(decimal == .484) {
decimal = .484375;
}
else if(decimal == .515) {
decimal = .515625;
}
else if(decimal == .531) {
decimal = .53125;
}
else if(decimal == .546) {
decimal = .546875;
}
else if(decimal == .562) {
decimal = .5625;
}
else if(decimal == .578) {
decimal = .578125;
}
else if(decimal == .593) {
decimal = .59375;
}
else if(decimal == .609) {
decimal = .609375;
}
else if (decimal == .625) {
decimal = .625;
}
else if(decimal == .640) {
decimal = .640625;
}
else if(decimal == .656) {
decimal = .65625;
}
else if(decimal == .671) {
decimal = .671875;
}
else if(decimal == .687) {
decimal = .6875;
}
else if(decimal == .703) {
decimal = .703125;
}
else if(decimal == .718) {
decimal = .71875;
}
else if(decimal == .734) {
decimal = .734375;
}
else if(decimal == .765) {
decimal = .765625;
}
else if(decimal == .781) {
System.out.println("Decimal is .781");
decimal = .78125;
}
else if(decimal == .796) {
decimal = .796875;
}
else if(decimal == .812) {
decimal = .8125;
}
else if(decimal == .828) {
decimal = .828125;
}
else if(decimal == .843) {
decimal = .84375;
}
else if(decimal == .859) {
decimal = .859375;
}
else if(decimal == .890) {
decimal = .890625;
}
else if(decimal == .906) {
decimal = .90625;
}
else if(decimal == .921) {
decimal = .921875;
}
else if(decimal == .937) {
decimal = .9375;
}
else if(decimal == .953) {
decimal = .953125;
}
else if(decimal == .968) {
decimal = .96875;
}
else if(decimal == .984) {
decimal = .984375;
}
if(!mantissa.equals("0.0")) {
fraction = getFraction(decimal);
}
}
//  Build final String number as whole part and the fractional value of the mantissa.
if(whole.equals("0")) {
result = fraction;
}
else {
if(fraction.equals("")) {
result = whole;
}
else {
result = whole + "-" + fraction.trim();
}
}
return result;
}
/**
  * getFraction -- Converts a decimal number to a fraction formatted String.
  *
  * @return the String fraction value of the input decimal value.
  */
private String getFraction(double value) {
String result = null;
double pos = 0.01;
double decimal = value;
double f;
int iterations = 5;
int a[] = new int[iterations];
int i, j, num, den, t;
for (i = 0; i < iterations; i++) {
f = Math.floor(decimal);
System.out.println("Math floor " + f + " for decimal value " + decimal);
a[i] = (int) f;
decimal = decimal - f;
if (pos > decimal) break;
decimal = 1. / decimal;
}
if (iterations <= i) {
i = iterations - 1;
}
num = a[i];
den = 1;
for (j = (i-1); j >= 0; j--) {
t = a[j] * num + den;
den = num;
num = t;
}
// Get greatest common denominator and calculate the
// value of the final numerator and denominator.
int gcd = getGreatestCommonDenominator(num, den);
int numerator = num / gcd;
int denominator = den / gcd;
// Build String value of numerator / denominator;
result = new String(numerator + "/" + denominator);
System.out.println("Result " + result);
return result;
}
/**
  * getGreatestCommonDenominator -- Determines the greatest common
  *                                 denominator of the two input values.
  *
  * @return the greatest common denominator.
  */
private int getGreatestCommonDenominator(int n, int d) {
int a = Math.abs(n);
int b = Math.abs(d);
for (; :wink:  {
if (0 == b)     return a;
a %= b;
if (0 == a)     return b;
b %= a;
}
}
}  

I appreciate ANY help anyone can give me on this. Thanks again!!

[Tom Blough]

Try this:

public class Fractions 
{
  public static void main(String[] args) 
  {
    System.out.println( Fractions.convert( .625, 16));  // 5/8
    System.out.println( Fractions.convert( .625, 15));  // 3/5
    System.out.println( Fractions.convert( .5, 16));  // 1/2
    System.out.println( Fractions.convert( .55, 16));  // 9/16
    System.out.println( Fractions.convert( .52, 16));  // 1/2
  }

  /**
   * This function converts a decimal number to the closest fraction with the
   * denominator specified by base, reduces it, and then returns a string
   * of the form +X X/X
   *
   * @param value the decimal value to convert
   * @param base the granularity of the denominator
   * @returns a fractional representation of the value
   */
  public static String convert( double value, int base)
  {
    String sign = " ";
    if( value < 0)
    {
      sign = "-";
      value = 0 - value;  // abs value
    }
    int intPart = (int) value;
    int fracPart = (int) (((value - intPart) * base) + 0.5);  //round to nearest int
    if( fracPart == 0)  // whole number
      return sign + intPart;
    else if( fracPart == base)  // whole number
      return sign + (intPart + 1);
    else  // reduce fraction
    {
      int divisor = gcd( fracPart, base);
      return sign + intPart + " " + (fracPart / divisor) + "/" + (base / divisor); 
    }
  }

  private static int gcd( int val1, int val2)
  {
    while( val2 != 0)
    {
      int tmp = val1 % val2;
      val1 = val2;
      val2 = tmp;
    }
    return val1;
  }
}

[ November 14, 2003: Message edited by: Tom Blough ]
[ November 14, 2003: Message edited by: Tom Blough ]

[Jaap van Hengstum]

Using continued fractions (I hope I've done this correctly since it was very late ):

public class Fraction
{
/**
 * Converts a decimal to a fraction using continued fractions.
 * 
 * @param decimal the decimal value to convert
 * @param tolerance the accuracy of the conversion 
 * @return a representation of the decimal as a fraction
 */
public static String fraction(double decimal, double tolerance) 
{
int sign = (decimal<0.0) ? -1 : 1;
decimal = Math.abs(decimal);

if (decimal == (int)decimal)
return (sign * (int)decimal + "/1");

double res = decimal, num=0.0, denom=1.0, lastdenom=0.0, temp;
do {
res = 1.0 / (res - (int)res);
temp = denom;
denom = denom * (int)res + lastdenom;
lastdenom = temp;
num = Math.round(decimal * denom);
} while (res!=(int)res && Math.abs(decimal - (num/denom)) > tolerance);

return (sign * (int)num + "/" + (int)denom);
}

public static void main(String[] args)
{

System.out.println(fraction(0.625, 10e-3)); // 5/8
System.out.println(fraction(0.26315789474, 10e-9)); // 5/19

System.out.println(fraction(0.6667, 10e-5)); // 2/3
System.out.println(fraction(0.6667, 10e-6)); // 6667/10000
System.out.println(fraction(Math.PI, 10e-2)); // 22/7
System.out.println(fraction(Math.PI, 10e-3)); // 22/7
System.out.println(fraction(Math.PI, 10e-4)); // 333/106
System.out.println(fraction(Math.PI, 10e-5)); // 333/106
System.out.println(fraction(Math.PI, 10e-6)); // 355/113
System.out.println(fraction(Math.PI, 10e-7)); // 355/113
System.out.println(fraction(Math.PI, 10e-8)); // 103993/33102
System.out.println(fraction(Math.PI, 10e-9)); // 103993/33102
System.out.println(fraction(Math.PI, 10e-10));// 103993/33102
System.out.println(fraction(Math.PI, 10e-11));// 312689/99532
}
}