fraction 0.2 → 0.3

data/README.md

@@ -1,14 +1,14 @@
-For a [cooking website][3] I recently worked on, 
-I needed to display decimal floating point numbers as fractions. I needed to 
-come up with the fraction closest to what the user typed. For example, 0.33 
-should resolve to ⅓. When I googled for a solution, most of the code I found 
+For a [cooking website][3] I recently worked on,
+I needed to display decimal floating point numbers as fractions. I needed to
+come up with the fraction closest to what the user typed. For example, 0.33
+should resolve to ⅓. When I googled for a solution, most of the code I found
 was slow, buggy, and worst of all, too precise (returning 33/100 for the above example.)
 
-I decided to widen my search to C, and [found][1] a piece of code on Stack Overflow 
-written by David Eppstein in 1993. 
-It uses the [theory of continued fractions][2] to approach the correct value, 
-but stops when the denominator reaches some value. The limitation of such an 
-algorithm is that we can't choose to leave out unnatural denominators 
+I decided to widen my search to C, and [found][1] a piece of code on Stack Overflow
+written by David Eppstein in 1993.
+It uses the [theory of continued fractions][2] to approach the correct value,
+but stops when the denominator reaches some value. The limitation of such an
+algorithm is that we can't choose to leave out unnatural denominators
 
 So became `fraction`: it's Eppstein's code in a Ruby gem.
 
@@ -19,24 +19,28 @@ Install it with `gem`:
 Using this gem is easy:
 
     require 'fraction'
-    num, den = 0.33.fraction   # num==1, den==3
+    num, den = 0.33.to_fraction   # num==1, den==3
+    num, den = 0.33.fraction # legacy name also works
 
-You can also get the error
+You can get the error:
 
-    num,den,err = 0.33.fraction   #=> [1, 3, -0.0033333333333333]
+    num,den,err = 0.33.to_fraction   #=> [1, 3, -0.0033333333333333]
 
 you can choose a different maximum denominator than the default value of 10:
- 
-    num, den = 0.51.fraction(100) #[51, 100, 0.0]
 
+    num, den = 0.51.to_fraction(100) #=> [51, 100, 0.0]
+
+There is also whole fraction support, which factors out any whole numbers:
+
+    whole, num, den, error = 3.5.to_whole_fraction #=> [3, 1, 2, 0]
 
 The best part of this gem over others is the speed:
 
-    % ruby test.rb 
+    % ruby test.rb
     I'm Feeling Lucky: 19.145s
     'fraction' gem: 2.090s
 
-subtracting the time required for an empty ruby loop, we can conclude the 
+subtracting the time required for an empty ruby loop, we can conclude the
 algorithm itself requires only ½ of a second for 1,000,000 iterations on my Mac Pro.
 
 

data/fraction.c

@@ -57,25 +57,35 @@ VALUE method_string_form_for(VALUE self)
    return res;
 }
 
-
-VALUE method_fraction_for(int argc, VALUE * argv, VALUE self)
+void core_fraction(double val, long maxden, long * n, long * d, double * e)
 {
-   long m11, m12,
-        m21, m22;
-   VALUE res = rb_ary_new2(3);
-   VALUE maxdenr;
-   int maxden = 10; // the default
-   rb_scan_args(argc, argv, "01", &maxdenr);
-   if (!NIL_P(maxdenr))
-     maxden = NUM2INT(maxdenr);
    int ai;
-   double x = NUM2DBL(self);
-   double startx = x;
-   m11 = m22 = 1;
-   m12 = m21 = 0;
+   long sign = 1;
+   long m11 = 1, m22 = 1;
+   long m12 = 0, m21 = 0;
+   if (val == NAN) {
+      *n = NAN;
+      *d = NAN;
+      *e = NAN;
+      return;
+   }
+   if (val == INFINITY) {
+      *n = INFINITY;
+      *d = 1.0;
+      *e = 0.0;
+      return;
+   }
+   if (val < 0.0) {
+      // work in positive space, it seems we can get confused by negatives
+      sign = -1;
+      val *= -1.0;
+   }
+   double x = val;
+   long count = 0;
 
    // loop finding terms until denom gets too big
    while (m21 *  ( ai = (long)x ) + m22 <= maxden) {
+      if (++count > 50000000) break; // break after 'too many' iterations
       long t = m11 * ai + m12;
       m12 = m11;
       m11 = t;
@@ -86,15 +96,34 @@ VALUE method_fraction_for(int argc, VALUE * argv, VALUE self)
       x = 1/(x - (double) ai);
       if(x>(double)0x7FFFFFFF) break;
    }
-   VALUE numer1 = INT2NUM(m11);
-   VALUE denom1 = INT2NUM(m21);
-   VALUE err1 = rb_float_new(startx - ((double) m11 / (double) m21));
+   *n = m11 * sign;
+   *d = m21;
+   *e = val - ((double)m11 / (double)m21);
+}
+
+
+VALUE method_fraction_for(int argc, VALUE * argv, VALUE self)
+{
+   VALUE res = rb_ary_new2(3);
+   VALUE maxdenr;
+   long maxden = 10; // the default
+   rb_scan_args(argc, argv, "01", &maxdenr);
+   if (!NIL_P(maxdenr))
+     maxden = NUM2INT(maxdenr);
+   double x = NUM2DBL(self);
+   long n, d;
+   double e;
+   core_fraction(x, maxden, &n, &d, &e);
+
+   VALUE numer1 = INT2NUM(n);
+   VALUE denom1 = INT2NUM(d);
+   VALUE err1 = rb_float_new(e);
    rb_ary_store(res, 0, numer1);
    rb_ary_store(res, 1, denom1);
    rb_ary_store(res, 2, err1);
-// Although the below is very cool, it's also quite slow to execute.
-  // rb_define_singleton_method(res, "to_s", method_string_form_for, 0);
-  // rb_define_singleton_method(res, "to_html", method_html_form_for, 0);
+   // Although the below is very cool, it's also quite slow to execute.
+   //rb_define_singleton_method(res, "to_s", method_string_form_for, 0);
+   //rb_define_singleton_method(res, "to_html", method_html_form_for, 0);
 
    /* We can go one more step to find another candidate:
       m11 = m11 * ai + m12;
@@ -113,32 +142,18 @@ VALUE method_whole_fraction_for(int argc, VALUE * argv, VALUE self)
         m21, m22;
    VALUE res = rb_ary_new2(4);
    VALUE maxdenr;
-   int maxden = 10; // the default
+   long maxden = 10; // the default
    rb_scan_args(argc, argv, "01", &maxdenr);
    if (!NIL_P(maxdenr))
      maxden = NUM2INT(maxdenr);
-   int ai;
    double x = NUM2DBL(self);
-   double startx = x;
-   m11 = m22 = 1;
-   m12 = m21 = 0;
-
-   // loop finding terms until denom gets too big
-   while (m21 *  ( ai = (long)x ) + m22 <= maxden) {
-      long t = m11 * ai + m12;
-      m12 = m11;
-      m11 = t;
-      t = m21 * ai + m22;
-      m22 = m21;
-      m21 = t;
-      if(x==(double)ai) break;
-      x = 1/(x - (double) ai);
-      if(x>(double)0x7FFFFFFF) break;
-   }
-   VALUE wholen = INT2NUM(m11 / m21);
-   VALUE numer1 = INT2NUM(m11 % m21);
-   VALUE denom1 = INT2NUM(m21);
-   VALUE err1 = rb_float_new(startx - ((double) m11 / (double) m21));
+   long n, d;
+   double e;
+   core_fraction(x, maxden, &n, &d, &e);
+   VALUE wholen = INT2NUM(n / d);
+   VALUE numer1 = INT2NUM(n % d);
+   VALUE denom1 = INT2NUM(d);
+   VALUE err1 = rb_float_new(e);
 
    rb_ary_store(res, 0, wholen);
    rb_ary_store(res, 1, numer1);

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  version: "0.2"
+  - 3
+  version: "0.3"
 platform: ruby
 authors: 
 - Christopher Lord