frac 0.9.3 → 0.9.4

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+group :development, :test do
+  gem "rake"
+  gem "jeweler"
+  gem "rcov"
+  gem "rdoc"
+  gem "rake-compiler"
+end
+

data/README.rdoc

@@ -1,33 +1,52 @@
-= Find rational approximation to given real number
-
-Convert Float to Rational with given denominator maximum
-
-  Math.frac(0.2, 100)  # => (1/5)
-  Math.frac(0.33, 10)  # => (1/3)
-  Math.frac(0.33, 100) # => (33/100)
-
-== Differe from ruby 1.9 build-in Float#to_r
-
-                                # Build-in
-  1.1.to_r                      # => (2476979795053773/2251799813685248)
-                                # Math#frac with big max denominator
-  Math.frac(1.1, 1_000_000_000) # => (11/10)  
-
-== Source
-
-Idea and most implementation from http://www.ics.uci.edu/~eppstein/numth/frap.c
-
-Based on the theory of continued fractions
-
-  if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
-
-then best approximation is found by truncating this series
-(with some adjustments in the last term).
-
-Note the fraction can be recovered as the first column of the matrix
-
-  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
-  ( 1  0 ) ( 1  0 ) ( 1  0 )
-  
-Instead of keeping the sequence of continued fraction terms,
-we just keep the last partial product of these matrices.
+= Find rational approximation to given real number
+
+Convert Float or String to Fraction with given denominator maximum.
+
+  Math::Fraction.new(0.2)               # => Fraction (1/5)
+  Math::Fraction.new("-3 1/8")          # => Fraction (-3 1/8)
+
+  Math::Fraction.new(0.333)             # => Fraction (1/3)
+  Math::Fraction.new("0.333")           # => Fraction (1/3)
+  Math::Fraction.new(0.33, 100)         # => Fraction (33/100)
+  Math::Fraction.new(1.to_f / 3)        # => Fraction (1/3)
+  
+  Math::Fraction.new(0.2).to_s          # => String "1/5" 
+  Math::Fraction.new(1.2).to_s          # => String "1 1/5"
+  Math::Fraction.new(1.2).to_r          # => Rational (6/5)
+  Math::Fraction.new(1.2).to_a          # => Array [1, 1, 5]
+  Math::Fraction.new("0.333").to_a      # => Array [0, 1, 3]
+
+  Math::Fraction.new(0.2, 100).to_r     # => Rational (1/5)
+  Math::Fraction.new(0.33, 10).to_r     # => Rational (1/3)
+  Math::Fraction.new(0.33, 100).to_r    # => Rational (33/100)
+
+== Difference from Ruby 1.9 built-in Float#to_r
+
+  # Built-in
+  1.1.to_r # => (2476979795053773/2251799813685248)
+
+  # Math::Fraction with big max denominator
+  Math::Fraction.new(1.1, 1_000_000_000_000_000_000).to_r  # => (11/10)
+
+== Installation
+
+  gem install frac
+
+== Source
+
+Idea and most implementation from http://www.ics.uci.edu/~eppstein/numth/frap.c
+
+Based on the theory of continued fractions
+
+  if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
+
+then best approximation is found by truncating this series
+(with some adjustments in the last term).
+
+Note the fraction can be recovered as the first column of the matrix
+
+  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
+  ( 1  0 ) ( 1  0 ) ( 1  0 )
+  
+Instead of keeping the sequence of continued fraction terms,
+we just keep the last partial product of these matrices.

data/Rakefile

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+  rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = %q{frac}
+  gem.homepage = %q{https://github.com/valodzka/frac}
+  gem.license = %q{}
+  gem.summary = %q{Find rational approximation to given real number}
+  gem.email = %q{pavel@valodzka.name}
+  gem.authors = [%q{Pavel Valodzka}]
+  gem.extensions = ["ext/extconf.rb"]
+  gem.require_paths = ["lib"]
+  gem.summary = <<-RDOC
+Find rational approximation to given real number.
+
+Based on the theory of continued fractions
+
+  if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
+
+then best approximation is found by truncating this series
+(with some adjustments in the last term).
+Note the fraction can be recovered as the first column of the matrix
+
+  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
+  ( 1  0 ) ( 1  0 ) ( 1  0 )
+
+Instead of keeping the sequence of continued fraction terms,
+we just keep the last partial product of these matrices.
+  RDOC
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new do |ext|
+  ext.ext_dir = 'ext'
+  ext.lib_dir = 'lib'
+  ext.name = 'frac_ext'
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*.rb'
+  test.verbose = true
+end
+
+task :default => [ :compile, :test ]
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "frac #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1,2 @@
+0.9.4
+

data/ext/extconf.rb

@@ -1,4 +1,3 @@
-
 require 'mkmf'
 
 create_makefile("frac_ext")

data/ext/frac_ext.c

@@ -1,90 +1,101 @@
-// 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
-**
-** usage: a.out r d
-**   r is real number to approx
-**   d is the maximum denominator allowed
-**
-** based on the theory of continued fractions
-** if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
-** then best approximation is found by truncating this series
-** (with some adjustments in the last term).
-**
-** Note the fraction can be recovered as the first column of the matrix
-**  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
-**  ( 1  0 ) ( 1  0 ) ( 1  0 )
-** Instead of keeping the sequence of continued fraction terms,
-** we just keep the last partial product of these matrices.
-*/
-
-#include <stdio.h>
-#include <ruby.h>
-
-#ifndef RFLOAT_VALUE
-#  define RFLOAT_VALUE(v) RFLOAT(rb_Float(v))->value
-#endif
-
-static VALUE find_fracs(VALUE mod, VALUE rv, VALUE dv) 
-{
-  VALUE ret;
-  long m[2][2];
-  double startx, x = RFLOAT_VALUE(rv);
-  long ai, maxden = NUM2LONG(dv);
-
-  if (maxden <= 0) 
-    rb_raise(rb_eArgError, "maximum denominator should be > 0");
-
-  startx = x;
-
-  /* initialize matrix */
-  m[0][0] = m[1][1] = 1;
-  m[0][1] = m[1][0] = 0;
-
-  /* loop finding terms until denom gets too big */
-  while (m[1][0] *  ( ai = (long)x ) + m[1][1] <= maxden) {
-    long t;
-    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;
-    if(x==(double)ai) break;     // AF: division by zero
-    x = 1/(x - (double) ai);
-    if(x>(double)0x7FFFFFFF) break;  // AF: representation failure
-  } 
-
-  {
-    /* now remaining x is between 0 and 1/ai */
-    /* approx as either 0 or 1/m where m is max that will fit in maxden */
-    /* first try zero */
-    VALUE num1, den1, err1, num2, den2, err2;
-
-    num1 = LONG2NUM(m[0][0]);
-    den1 = LONG2NUM(m[1][0]);
-    err1 = rb_float_new(startx - ((double) m[0][0] / (double) m[1][0]));
-
-    /* now try other possibility */
-    ai = (maxden - 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];
-
-    num2 = LONG2NUM(m[0][0]);
-    den2 = LONG2NUM(m[1][0]);
-    err2 = rb_float_new(startx - ((double) m[0][0] / (double) m[1][0]));
-
-    return rb_ary_new3(6, num1, den1, err1, num2, den2, err2);
-  }
-}
-
-
-void Init_frac_ext() 
-{
-  rb_define_module_function(rb_mMath, "find_fracs", find_fracs, 2);
-}
-
-
+/*
+** find rational approximation to given real number
+** David Eppstein / UC Irvine / 8 Aug 1993
+**
+** With corrections from Arno Formella, May 2008
+**
+** usage: a.out r d
+**   r is real number to approx
+**   d is the maximum denominator allowed
+**
+** based on the theory of continued fractions
+** if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
+** then best approximation is found by truncating this series
+** (with some adjustments in the last term).
+**
+** Note the fraction can be recovered as the first column of the matrix
+**  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
+**  ( 1  0 ) ( 1  0 ) ( 1  0 )
+** Instead of keeping the sequence of continued fraction terms,
+** we just keep the last partial product of these matrices.
+*/
+
+#include <stdio.h>
+#include <ruby.h>
+
+#ifndef RFLOAT_VALUE
+#  define RFLOAT_VALUE(v) RFLOAT(rb_Float(v))->value
+#endif
+
+#ifdef HAVE_LONG_LONG
+#  define N_TYPE LONG_LONG
+#  define R2N NUM2LL
+#  define N2R LL2NUM
+#else
+#  define N_TYPE long
+#  define R2N NUM2LONG
+#  define N2R LONG2NUM
+#endif
+
+static VALUE find_fracs(VALUE mod, VALUE rv, VALUE dv) 
+{
+  VALUE ret;
+  N_TYPE m[2][2], ai, maxden = R2N(rb_Integer(dv));
+  double startx, x = RFLOAT_VALUE(rb_Float(rv));
+  int sign = 1;
+
+  if (maxden <= 0)
+    rb_raise(rb_eArgError, "maximum denominator should be > 0");
+
+  if (x < 0) {
+    sign = -1;
+    x = -x;
+  }
+
+  startx = x;
+
+  /* initialize matrix */
+  m[0][0] = m[1][1] = 1;
+  m[0][1] = m[1][0] = 0;
+
+  /* loop finding terms until denom gets too big */
+  while (m[1][0] *  ( ai = (N_TYPE)x ) + m[1][1] <= maxden) {
+    N_TYPE t;
+    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;
+    if(x==(double)ai) break;     // AF: division by zero
+    x = 1/(x - (double) ai);
+    if(x>(double)0x7FFFFFFF) break;  // AF: representation failure
+  } 
+
+  {
+    /* now remaining x is between 0 and 1/ai */
+    /* approx as either 0 or 1/m where m is max that will fit in maxden */
+    /* first try zero */
+    VALUE num1, den1, err1, num2, den2, err2;
+
+    num1 = N2R(sign*m[0][0]);
+    den1 = N2R(m[1][0]);
+    err1 = rb_float_new(startx - ((double) m[0][0] / (double) m[1][0]));
+
+    /* now try other possibility */
+    ai = (maxden - 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];
+
+    num2 = N2R(sign*m[0][0]);
+    den2 = N2R(m[1][0]);
+    err2 = rb_float_new(startx - ((double) m[0][0] / (double) m[1][0]));
+
+    return rb_ary_new3(6, num1, den1, err1, num2, den2, err2);
+  }
+}
+
+void Init_frac_ext() 
+{
+  rb_define_module_function(rb_mMath, "find_fracs", find_fracs, 2);
+}

data/frac.gemspec

@@ -0,0 +1,53 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{frac}
+  s.version = "0.9.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pavel Valodzka"]
+  s.date = %q{2011-06-19}
+  s.email = %q{pavel@valodzka.name}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "README.rdoc",
+    "VERSION",
+    "ext/extconf.rb",
+    "ext/frac_ext.c",
+    "frac.gemspec",
+    "lib/frac.js",
+    "lib/frac.rb",
+    "test/frac_test.html",
+    "test/frac_test.rb"
+  ]
+  s.homepage = %q{https://github.com/valodzka/frac}
+  s.licenses = [""]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Find rational approximation to given real number.  Based on the theory of continued fractions  if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))  then best approximation is found by truncating this series (with some adjustments in the last term). Note the fraction can be recovered as the first column of the matrix  ( a1 1 ) ( a2 1 ) ( a3 1 ) ... ( 1  0 ) ( 1  0 ) ( 1  0 )  Instead of keeping the sequence of continued fraction terms, we just keep the last partial product of these matrices.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/frac.js

@@ -0,0 +1,41 @@
+
+(function(){
+    var find_fracs = function(x, maxden) {
+        var startx = x, ai;
+        var m = [[1.0, 0.0],[0.0, 1.0]];
+
+        if (maxden <= 0) 
+            throw "Max denominator should be greater then 0";
+
+        while (m[1][0] * (ai = parseInt(x)) + m[1][1] <= maxden) {
+            var 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;
+            if (x == ai) break; /* AF: division by zero */
+            x = 1/(x - ai);
+            if (x > 0x7FFFFFFF) break /* AF: representation failure */
+        }
+        
+        var num1 = m[0][0];
+        var den1 = m[1][0];
+        var err1 = startx - num1 / den1;
+    
+        ai = (maxden - 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];
+    
+        var num2 = m[0][0];
+        var den2 = m[1][0];
+        var err2 = startx - num2 / den2;
+
+        return [err1, [num1, den1], err2, [num2, den2]];
+    };
+
+    Math["frac"] = function(x, maxden) {
+        var fracs = find_fracs(parseFloat(x), parseInt(maxden));
+        return Math.abs(fracs[0]) < Math.abs(fracs[2]) ? fracs[1] : fracs[3];
+    };
+})();

data/lib/frac.rb

@@ -1,15 +1,62 @@
-
-require 'rational'
-require 'frac_ext'
-
-module Math
-  class << self
-    private :find_fracs
-
-    # Find rational approximation to given real number.
-    def frac(float, maxden)
-      arr = find_fracs(Float(float), Integer(maxden))
-      arr[2].abs > arr[5].abs ? Rational(arr[3], arr[4]) : Rational(arr[0], arr[1])
-    end
-  end
-end
+require 'rational'
+require File.join(File.dirname(__FILE__), %w{.. lib frac_ext})
+
+# Rational approximation to given real number.
+module Math
+
+  class << self
+    private :find_fracs
+    
+    def frac(float, maxden)
+      arr = find_fracs(float, maxden)
+      arr[2].abs > arr[5].abs ? Rational(arr[3], arr[4]) : Rational(arr[0], arr[1])
+    end
+  end
+  
+  class Fraction
+
+    def initialize(float, maxden = 0x100)
+      if float.is_a?(String)
+        @r = 0
+        sign = 1
+        float.split(' ', 2).each do |part|
+          if (part.include?("/"))
+            @r += sign * Rational(*(part.split('/', 2).map(&method(:Integer))))
+          else
+            @r += Math.frac(part, maxden)
+            sign = @r >= 0 ? 1 : -1
+          end
+        end
+      else
+        @r = Math.frac(float, maxden)
+      end
+    end
+    
+    def to_a
+      i = @r.to_i
+      sign = i >= 0 ? 1 : -1
+      [ i, (@r.numerator - i * @r.denominator) * sign, @r.denominator ]
+    end
+    
+    def to_r
+      @r
+    end
+
+    def to_f
+      @r.to_f
+    end
+    
+    def to_s
+      n = to_a
+      if n[1] == 0
+        n[0].to_s
+      elsif n[0] == 0
+        "#{n[1]}/#{n[2]}"
+      else
+        "#{n[0]} #{n[1]}/#{n[2]}"
+      end    
+    end  
+    
+  end
+end
+

data/test/frac_test.html

@@ -0,0 +1,39 @@
+
+<script src="../lib/frac.js" type="text/javascript"></script>
+
+<script>
+  function msg(str) {
+    document.write(str);
+  };
+
+  function err(str) {
+    msg("<p style='color:red;'>"+str+"</p>");
+  };
+
+  function ok(str) {
+    msg("<p style='color:green'>"+str+"</p>");
+  };
+
+  function assert(expected, result, msg) {
+    if (expected != result && expected.toString() != result.toString()) 
+      err("Error, expected " + expected + ", got " + result + ": " + msg);
+    else
+      ok("OK: " + msg);
+  };
+
+  var tests = [
+  [ 0.333,[ 1,   3], 0x100],
+  [ 0.77, [77, 100], 0x100],
+  [ 0.2,  [ 1,   5], 0x100],
+  [ 2,    [ 2,   1], 0x100],
+  [-0.5,  [-1,    2], 0x100],
+  [ 0,    [ 0,   1], 0x100],
+  ["0.85",[17,  20], 0x100],
+  [ 0.5,  [ 1,   2], '1000'],
+  [ 0.001,[ 0,   1], 2]];
+
+  for (var i = 0; i < tests.length; ++i) {
+    var sample = tests[i];
+    assert(sample[1], Math.frac(sample[0], sample[2]), sample[0] + " -> " + sample[1][0] + " / " + sample[1][1]);                 
+  }
+</script>

data/test/frac_test.rb

@@ -3,17 +3,40 @@ require File.join(File.dirname(__FILE__), %w{.. lib frac})
 
 class TC_Frac < Test::Unit::TestCase
   def test_frac
-    [[ 0.333, 1,   3, 0x100],
-     [ 0.77, 77, 100, 0x100],
-     [ 0.2,   1,   5, 0x100],
-     [ 2,     2,   1, 0x100],
-     [-0.5,  -1,   2, 0x100],
-     [ 0,     0,   1, 0x100],
-     ["0.85",17,  20, 0x100],
-     [ 0.5,   1,   2, '1000'],
-     [ 0.001, 0,   1, 2]
-    ].each{|float, num, den, prec|
-      assert_equal Rational(num, den), Math.frac(float, prec), "#{float.inspect} -> #{num} / #{den}"
+    [[ 0.333,    [1, 3],  0x100,    [0, 1, 3],     "1/3" ],
+     [ 1.to_f/3, [1, 3],  0x100,    [0, 1, 3],     "1/3" ],
+     [ 0.77,  [77, 100],  0x100, [0, 77, 100],  "77/100" ],
+     [ 0.2,      [1, 5],  0x100,    [0, 1, 5],     "1/5" ],
+     [ 2,        [2, 1],  0x100,    [2, 0, 1],       "2" ],
+     [-0.5,     [-1, 2],  0x100,   [0, -1, 2],    "-1/2" ],
+     [-1.5,     [-3, 2],  0x100,   [-1, 1, 2],  "-1 1/2" ],
+     [-1.7,   [-17, 10],  0x100,  [-1, 7, 10],  "-1 7/10" ],
+     [-2.7,   [-27, 10],     10,  [-2, 7, 10],  "-2 7/10" ],
+     [ 0,        [0, 1],  0x100,    [0, 0, 1],       "0" ],
+     [ 0.85,   [17, 20],  0x100,  [0, 17, 20],   "17/20" ],
+     [ 0.5,      [1, 2], '1000',    [0, 1, 2],     "1/2" ],
+     [ 0.001,    [0, 1],      2,    [0, 0, 1],       "0" ],
+     [ 0.001, [1, 1000],   1000, [0, 1, 1000],  "1/1000" ],
+     [ 3.56,   [89, 25],  0x100,  [3, 14, 25], "3 14/25" ],
+     [ "3.56",   [89, 25],  0x100,  [3, 14, 25], "3 14/25" ],
+    ].each{|float, num_den, prec, n, s|
+      assert_equal Rational(num_den[0], num_den[1]), Math.frac(float, prec), "#{float.inspect} -> #{num_den[0]} / #{num_den[1]}"
+      assert_equal n, Math::Fraction.new(float, prec).to_a, "#{float.inspect} -> #{n}"
+      assert_equal s, Math::Fraction.new(float, prec).to_s, "#{float.inspect} -> #{s}"
+    }
+  end
+  
+  def test_frac_strings
+    [[ "0.333",     [0, 1, 3],     "1/3", 1.to_f / 3 ],
+     [ "3.56",    [3, 14, 25], "3 14/25", 3.56 ],
+     [ "3 1/8",     [3, 1, 8],   "3 1/8", 3.125 ],
+     [ "-3 1/8",   [-3, 1, 8],  "-3 1/8", -3.125 ],
+     [ "-1/8",     [0, -1, 8],    "-1/8", -0.125 ],
+    ].each{|float, n, s, f|
+      r = Math::Fraction.new(float)
+      assert_equal n, r.to_a, "#{float.inspect} -> #{n}"
+      assert_equal s, r.to_s, "#{float.inspect} -> #{s}"
+      assert_equal f, r.to_f, "#{float.inspect} -> #{f}"
     }
   end
 	
@@ -23,11 +46,19 @@ class TC_Frac < Test::Unit::TestCase
     end
   end
 	
-  def test_validation
+  def test_frac_validation
     [[1.1, ''], [nil, 0x100], [1.1, 0], [1.5, -100]].each{|params|
       assert_raise ArgumentError, TypeError do
         Math.frac(*params)
       end
     }
   end
+
+  def test_fractions_validation
+    ['junk', 'junk 2/3', '10 junk/2', '11 3/junk', nil].each{|param|
+      assert_raise ArgumentError, TypeError, "For param #{param}" do
+        Math::Fraction.new(param)
+      end
+    }
+  end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: frac
 version: !ruby/object:Gem::Version 
+  hash: 51
   prerelease: false
   segments: 
   - 0
   - 9
-  - 3
-  version: 0.9.3
+  - 4
+  version: 0.9.4
 platform: ruby
 authors: 
 - Pavel Valodzka
@@ -14,53 +15,132 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-26 00:00:00 +03:00
+date: 2011-06-24 00:00:00 +03:00
 default_executable: 
-dependencies: []
-
-description: Find rational approximation to given real number
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rake
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rcov
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rdoc
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rake-compiler
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+description: 
 email: pavel@valodzka.name
 executables: []
 
 extensions: 
 - ext/extconf.rb
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
 files: 
-- ext/frac_ext.c
+- Gemfile
+- README.rdoc
+- Rakefile
+- VERSION
 - ext/extconf.rb
+- ext/frac_ext.c
+- frac.gemspec
+- lib/frac.js
 - lib/frac.rb
+- test/frac_test.html
 - test/frac_test.rb
-- README.rdoc
 has_rdoc: true
-homepage: http://github.com/valodzka/frac
-licenses: []
-
+homepage: https://github.com/valodzka/frac
+licenses: 
+- ""
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Find rational approximation to given real number.  Based on the theory of continued fractions  if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))  then best approximation is found by truncating this series (with some adjustments in the last term). Note the fraction can be recovered as the first column of the matrix  ( a1 1 ) ( a2 1 ) ( a3 1 ) ... ( 1  0 ) ( 1  0 ) ( 1  0 )  Instead of keeping the sequence of continued fraction terms, we just keep the last partial product of these matrices.
 test_files: []