CFraction - a double / fraction / string conversion class

• Download source files - 4.21 Kb

Introduction

The CFraction class is a handy class when dealing with doubles and fractions. You can use it like a double and do anything you would do with a double, plus you assign strings to it. When you need to get a string representation, use one of the methods returning a CString. Or, if you do not use CString, there are methods for char *.

Example usage:

  CFraction F1,F2;
  double D;
  CString S;
 
  // Assignment

  F1 = 5.126;        // double

  F2 = "5.126";      // string

  F1 = "5 63/500";   // string with fraction


  D = F1;            // double = CFraction

  F2 = D;            // CFraction = double


  // Math

  F1 = F2 + D;       // Mix and match them

  F2 = F1/D;
  // any math operation you want


  // Comparison

  if ((F1 > D) || (F1 < F2))
    D = F2/F1;
                      
  F2 = 15.0135;      // 5 27/2000

  
  S = F2.ToString(); // Returns "5 27/2000" 


  // Another version of ToString limits 

  // the denominator to the passed maximum value.

  S = F2.ToString(64); 
  // Returns "15 1/64" because 64 was exceeded

  // with first estimate 1/74 


  // Or, if you are working with stock prices

  // and you only want to show fractions when

  // the deniminator is 2,4,8,16,32,64,128,or 256

  // or up to passed maximum denominator ( <= 256) 

  S = F2.ToStockString(); 
  // Returns "15.0135" because fraction is not a normal stock price  


  // Or, force the denominator to be a valid

  // stock price denominator up to passed Max. Den. 

  S = F2.ForceToStockString();   // Returns closest stock price "15 3/256"

  S = F2.ForceToStockString(64); // Returns closest stock price "15 1/64" 

  
  // If you are like me, you are wondering what it will do with PI :-)

  F1 = 3.1415926535897932384626433832795; 
  // From Calculator - well beyond doubles capability

  S = F1.ToString(); // Returns  "3 3612111/25510582"

  // The difference is about 5.79087e-16 

  
  // You can increase precision when you know

  // that a value has a very large denominator. 

  // A double passed to ToString specifies the allowed error to shoot for. 

  // Warning: Using a smaller allowed error

  // can cause invalid results for fractions that 

  // can be accurately converted using a larger

  // allowed error. Also, since __int64 is used,

  // a denomintor cannot exceed 18 or 19 digits.

  S = F1.ToString(10.0e-50); 
  // Pushing it way up returns "3 36853866/260280919" 

  // The difference to double precision

  // is 0 because doubles accuracy was reached. 

  // The actual difference is about 1.27274e-16. 

  
  // If you have access to a more accurate type (like Calculator does),

  // you can replace double in the code

  // to increase accuracy. You can also 

  // replace __int64 if you want a denominator >  18 digits.


  // Lets try a resonable maximum denominator fo PI, like 999

  S = F1.ToString(999); // returns "3 16/113"


  // The first three estimates this class gives

  // for PI are 3 1/7, 3 15/106, and 3 16/113

The algorithm was developed using the formula for converting a decimal fraction to a string fraction. Any fractional part can be represented as:

1/(I₁ + 1/(I₂ + 1/(I₃ + 1/I_n ...

where I₁ is the integer part of the reciprocal of the fraction and I₂ is the integer part of the reciprocal minus I₁ ... etc. To determine the integer numerator and denominator, the expression can be reduced. It turns out that the numerator is simpler to calculate than the denominator, so the denominator can simply be determined by dividing the numerator by the original decimal.

Reduction of 1/(I₁ + 1/(I₂ + 1/(I₃ + 1/I_n ... ))) - There is a way to mathematically reduce this elegantly. However, I think a simple step by step algebraic approach will be understood by more readers.

• 1 I term: 1/I₁ Numerator N₁ = 1
• 2 I terms: 1/(I₁ + 1/I₂) Multiply by I₂/I₂ = I₂/((I₁*I₂) + 1),

  Numerator N₂ = I₂

• 3 I terms: 1/(I₁ + 1/(I₂ + 1/I₃)) Multiply by I₃/I₃ = 1/(I₁ + I₃/(I₂*I₃) + 1)

  then Multiply by ((I₂*I₃) + 1)/((I₂*I₃) + 1) = ((I₂*I₃) + 1)/(I₁*((I₂*I₃) + 1) + I₃),

  Numerator N₃ = ((I₂*I₃) + 1)

• 4 I terms: ...

  Multiply by I₄/I₄ = 1/(I₁ + 1/(I₂ + I₄/(I₃*I₄) + 1))

  Multiply by (I₃*I₄) + 1) = 1/(I₁ + ((I₃*I₄) + 1)/(I₂*((I₃*I₄) + 1) + I₄)).. ,

  Numerator N₄ = I₂*((I₃*I₄) + 1) + I₄

As we continue, a pattern to the numerators appears showing that N₁ = 1, N₂ = I₂, and N_n = I_n*N_n-2 + N_n-3 .

This is fairly simple to code.