large_binomials 1.0.0 → 1.0.1

data/README.md

@@ -13,11 +13,9 @@ and larger.
 Installation
 ------------
 
-Do the following to install this gem:
+You can install this gem from RubyGems doing the following:
 
-1. Make a clone of the repository
-2. Build the gem: `gem build large_binomials.gemspec`
-3. Install the gem: `gem install ./large_binomials-0.9.gem`
+	gem install large_binomials
 
 Usage
 -----

data/Rakefile

@@ -1,5 +1,7 @@
+# encoding: utf-8
+#
 # Ruby Library to Calculate Large Binomials
-# Copyright © 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
+# Copyright (c) 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
 #
 # This file is part of the Ruby Library to Calculate Large Binomials.
 #
@@ -7,39 +9,41 @@
 # redistribute it and/or modify it under the terms of the GNU General Public
 # License as published by the Free Software Foundation, either version 3 of the
 # License, or (at your option) any later version.
-# 
+#
 # The Ruby Library to Calculate Large Binomials is distributed in the hope that
-# it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-# Public License for more details.
-# 
+# it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
 # You can find a copy of the GNU General Public License in /LICENSE
 #
 
 require 'rspec/core/rake_task'
- 
+
 desc 'Default: run specs.'
 task :default => :spec
- 
+
 desc 'Run specs'
 RSpec::Core::RakeTask.new do |t|
-	t.pattern = "./spec/**/*_spec.rb"
+  t.pattern = './spec/**/*_spec.rb'
 end
 
 def find_integer_methods
-	require_relative 'lib/core_ext/integer'
-	integer_methods = Integer.instance_methods(false)
-	integer_methods.select!{ | m | 1.method(m).source_location != nil }
-	integer_methods.select!{ | m | 1.method(m).source_location[0].include? 'large_binomials'}
-	integer_methods.collect{ | m | "::Integer##{m}"}
+  require_relative 'lib/core_ext/integer'
+  integer_methods = Integer.instance_methods(false)
+  integer_methods.select! { | m | 1.method(m).source_location.nil? }
+  integer_methods.select! do | m |
+    1.method(m).source_location[0].include? 'large_binomials'
+  end
+  integer_methods.map { | m | "::Integer##{m}" }
 end
 
 desc 'Run Mutant'
 task :mutant do
-	require 'mutant'
-	find_integer_methods
-	status = Mutant::CLI.run(['::LargeBinomials*', find_integer_methods, '--rspec-unit'].flatten)
-	if status.nonzero?
-		abort 'Mutant task is not successful'
-	end
-end
+  require 'mutant'
+  find_integer_methods
+  status = Mutant::CLI.run(['--require', 'large_binomials',
+                            '::LargeBinomials*', find_integer_methods,
+                            '--rspec'].flatten)
+  abort 'Mutant task is not successful' if status.nonzero?
+end

data/large_binomials.gemspec

@@ -20,7 +20,7 @@
 
 Gem::Specification.new do |gem|
 	gem.name = 'large_binomials'
-	gem.version = '1.0.0'
+	gem.version = '1.0.1'
 	gem.authors = [ 'Filip van Laenen' ]
 	gem.email = [ 'f.a.vanlaenen@ieee.org' ]
 

data/lib/core_ext/integer.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 #
 # Ruby Library to Calculate Large Binomials
-# Copyright © 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
+# Copyright (C) 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
 #
 # This file is part of the Ruby Library to Calculate Large Binomials.
 #
@@ -9,119 +9,118 @@
 # redistribute it and/or modify it under the terms of the GNU General Public
 # License as published by the Free Software Foundation, either version 3 of the
 # License, or (at your option) any later version.
-# 
+#
 # The Ruby Library to Calculate Large Binomials is distributed in the hope that
-# it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-# Public License for more details.
-# 
+# it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
 # You can find a copy of the GNU General Public License in /LICENSE
 #
 
 class Integer
+  def to_lf
+    LargeBinomials::LargeFloat.new(self)
+  end
 
-	def to_lf
-		LargeBinomials::LargeFloat.new(self)
-	end
-
-	def binomial(k)
-		binomial = breaking_binomial_by_product_of_divisions(k)
-		if binomial == nil
-			large_float_binomial_by_product_of_divisions(k)
-		else
-			binomial
-		end
-	end
-
-	# Copied from http://rosettacode.org/wiki/Evaluate_binomial_coefficients#Ruby (on 7 June 2013)
-	def binomial_by_product_of_divisions(k)
-		(0...k).inject(1) do |m,i|
-			(m * (self - i)) / (i + 1)
-		end
-	end
+  def binomial(k)
+    binomial = breaking_binomial_by_product_of_divisions(k)
+    if binomial.nil?
+      large_float_binomial_by_product_of_divisions(k)
+    else
+      binomial
+    end
+  end
 
-	# Breaking version of binomial_by_product_of_divisions
-	def breaking_binomial_by_product_of_divisions(k)
-		(0...k).inject(1) do |m,i|
-			if m > Float::MAX
-				return nil
-			end
-			(m * (self - i)) / (i + 1)
-		end
-	end
+  # Copied from http://rosettacode.org/wiki/Evaluate_binomial_coefficients#Ruby
+  # (on 7 June 2013)
+  def binomial_by_product_of_divisions(k)
+    (0...k).reduce(1) do |m, i|
+      (m * (self - i)) / (i + 1)
+    end
+  end
 
-	# LargeFloat version of binomial_by_product_of_divisions
-	def large_float_binomial_by_product_of_divisions(k)
-		(0...k).inject(1.to_lf) do |m,i|
-			(m * (self - i)) / (i + 1)
-		end
-	end
+  # Breaking version of binomial_by_product_of_divisions
+  def breaking_binomial_by_product_of_divisions(k)
+    (0...k).reduce(1) do |m, i|
+      return nil if m > Float::MAX
+      (m * (self - i)) / (i + 1)
+    end
+  end
 
-	# Float version of binomial_by_product_of_divisions
-	def float_binomial_by_product_of_divisions(k)
-		(0...k).inject(1.to_f) do |m,i|
-			(m * (self - i)) / (i + 1)
-		end
-	end
+  # LargeFloat version of binomial_by_product_of_divisions
+  def large_float_binomial_by_product_of_divisions(k)
+    (0...k).reduce(1.to_lf) do |m, i|
+      (m * (self - i)) / (i + 1)
+    end
+  end
 
-	# From http://rosettacode.org/wiki/Evaluate_binomial_coefficients#Ruby (on 7 June 2013)
-	def binomial_by_division_of_products(k)
-		# n!/(n-k)!
-		pTop = (self-k+1 .. self).inject(1, &:*) 
-		# k!
-		pBottom = (2 .. k).inject(1, &:*)
-		pTop / pBottom
-	end
+  # Float version of binomial_by_product_of_divisions
+  def float_binomial_by_product_of_divisions(k)
+    (0...k).reduce(1.to_f) do |m, i|
+      (m * (self - i)) / (i + 1)
+    end
+  end
 
-	# Parallel version of binomial_by_division_of_products
-	# Note that threads in Ruby 1.9 don't spread over multiple processors, so
-	# due to context switching this parallel version will often be a bit slower
-	# than the sequential one.
-	def binomial_by_division_of_parallel_products(k)
-		# n!/(n-k)!
-		top_thread = Thread.new do
-			Thread.current[:output] = (self-k+1 .. self).inject(1, &:*) 
-		end
-		# k!
-		bottom_thread = Thread.new do
-			Thread.current[:output] = (2 .. k).inject(1, &:*)
-		end
-		top_thread.join
-		bottom_thread.join
-		top_thread[:output] / bottom_thread[:output]
-	end
+  # From http://rosettacode.org/wiki/Evaluate_binomial_coefficients#Ruby (on 7
+  # June 2013)
+  def binomial_by_division_of_products(k)
+    # n!/(n-k)!
+    p_top = (self - k + 1 .. self).inject(1, &:*)
+    # k!
+    p_bottom = (2 .. k).inject(1, &:*)
+    p_top / p_bottom
+  end
 
-	# LargeFloat version of binomial_by_division_of_products
-	def large_float_binomial_by_division_of_products(k)
-		# n!/(n-k)!
-		pTop = (self-k+1 .. self).inject(1.to_lf, &:*) 
-		# k!
-		pBottom = (2 .. k).inject(1.to_lf, &:*)
-		pTop / pBottom
-	end
+  # Parallel version of binomial_by_division_of_products
+  # Note that threads in Ruby 1.9 don't spread over multiple processors, so
+  # due to context switching this parallel version will often be a bit slower
+  # than the sequential one.
+  def binomial_by_division_of_parallel_products(k)
+    # n!/(n-k)!
+    top_thread = Thread.new do
+      Thread.current[:output] = (self - k + 1 .. self).inject(1, &:*)
+    end
+    # k!
+    bottom_thread = Thread.new do
+      Thread.current[:output] = (2 .. k).inject(1, &:*)
+    end
+    top_thread.join
+    bottom_thread.join
+    top_thread[:output] / bottom_thread[:output]
+  end
 
-	# Float version of binomial_by_division_of_products
-	def float_binomial_by_division_of_products(k)
-		# n!/(n-k)!
-		pTop = (self-k+1 .. self).inject(1.to_f, &:*) 
-		# k!
-		pBottom = (2 .. k).inject(1.to_f, &:*)
-		pTop / pBottom
-	end
+  # LargeFloat version of binomial_by_division_of_products
+  def large_float_binomial_by_division_of_products(k)
+    # n!/(n-k)!
+    p_top = (self - k + 1 .. self).inject(1.to_lf, &:*)
+    # k!
+    p_bottom = (2 .. k).inject(1.to_lf, &:*)
+    p_top / p_bottom
+  end
 
-	# Copied from http://www.brpreiss.com/books/opus8/html/page459.html (on 7 June 2013)
-	def binomial_by_pascals_triangle(k)
-		b = []
-		b[0] = 1
-		for i in 1 .. self
-			b[i] = 1
-			j = i - 1
-			while j > 0
-				b[j] += b[j - 1]
-				j -= 1
-			end
-		end
-		b[k]
-	end
+  # Float version of binomial_by_division_of_products
+  def float_binomial_by_division_of_products(k)
+    # n!/(n-k)!
+    p_top = (self - k + 1 .. self).inject(1.to_f, &:*)
+    # k!
+    p_bottom = (2 .. k).inject(1.to_f, &:*)
+    p_top / p_bottom
+  end
 
-end
+  # Copied from http://www.brpreiss.com/books/opus8/html/page459.html (on 7
+  # June 2013)
+  def binomial_by_pascals_triangle(k)
+    b = []
+    b[0] = 1
+    (1 .. self).each do | i |
+      b[i] = 1
+      j = i - 1
+      while j > 0
+        b[j] += b[j - 1]
+        j -= 1
+      end
+    end
+    b[k]
+  end
+end

data/lib/large_binomials/large_float.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 #
 # Ruby Library to Calculate Large Binomials
-# Copyright © 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
+# Copyright (c) 2013 Filip van Laenen <f.a.vanlaenen@ieee.org>
 #
 # This file is part of the Ruby Library to Calculate Large Binomials.
 #
@@ -9,121 +9,119 @@
 # redistribute it and/or modify it under the terms of the GNU General Public
 # License as published by the Free Software Foundation, either version 3 of the
 # License, or (at your option) any later version.
-# 
+#
 # The Ruby Library to Calculate Large Binomials is distributed in the hope that
-# it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
-# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
-# Public License for more details.
-# 
+# it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
 # You can find a copy of the GNU General Public License in /LICENSE
 #
 
 module LargeBinomials
-	class LargeFloat
-		include Comparable
-
-		attr_accessor :exponent, :mantissa
-
-		def initialize(m, e = 0)
-			@mantissa = m.to_f
-			@exponent = e
-		end
-
-		def clone
-			LargeFloat.new(@mantissa, @exponent)
-		end
-
-		def normalize
-			unless @mantissa == 0
-				normalization = Math.log10(@mantissa).floor
-				@mantissa /= 10 ** normalization
-				@exponent += normalization
-			end
-		end
-
-		def *(x)
-			if (x.instance_of? LargeFloat)
-				multiply_with_large_float(x)
-			else
-				multiply_with_numeric(x)
-			end
-		end
-
-		def multiply_with_large_float(lf)
-			product = self * lf.mantissa
-			product.exponent += lf.exponent
-			product
-		end
-
-		def multiply_with_numeric(i)
-			product = clone
-			new_mantissa = product.mantissa * i
-			if new_mantissa == Float::INFINITY
-				product.normalize
-			end
-			product.mantissa *= i
-			product
-		end
-
-		def /(x)
-			if (x.instance_of? LargeFloat)
-				divide_by_large_float(x)
-			else
-				divide_by_numeric(x)
-			end
-		end
-
-		def divide_by_large_float(lf)
-			quotient = self / lf.mantissa
-			quotient.exponent -= lf.exponent
-			quotient
-		end
-
-		def divide_by_numeric(n)
-			quotient = clone
-			quotient.mantissa /= n
-			quotient
-		end
-
-		def new_mantissa_for_addition(lf)
-			@mantissa + lf.mantissa * 10 ** (lf.exponent - @exponent)
-		end
-
-		def +(lf)
-			if self < lf
-				lf + self
-			else
-				LargeFloat.new(new_mantissa_for_addition(lf), @exponent)
-			end
-		end
-
-		def superscript(i)
-			s = i.to_s
-			s = s.gsub(/1/, '¹')
-			s = s.gsub(/2/, '²')
-			s = s.gsub(/3/, '³')
-			s = s.gsub(/4/, '⁴')
-			s = s.gsub(/5/, '⁵')
-			s = s.gsub(/6/, '⁶')
-			s = s.gsub(/7/, '⁷')
-			s = s.gsub(/8/, '⁸')
-			s = s.gsub(/9/, '⁹')
-			s.gsub(/0/, '⁰')
-		end
-
-		def to_s
-			normalize
-			"#{@mantissa}×10#{superscript(@exponent)}"
-		end
-
-		def <=>(lf)
-			normalize
-			lf.normalize
-			if @exponent == lf.exponent
-				@mantissa - lf.mantissa
-			else
-				@exponent - lf.exponent
-			end
-		end
-	end
-end
+  # Class modeling floats larger than Ruby's regular float. They consist of a
+  # regular float (the mantissa) plus an additional exponent of 10.
+  class LargeFloat
+    include Comparable
+
+    attr_accessor :exponent, :mantissa
+
+    def initialize(m, e = 0)
+      @mantissa = m.to_f
+      @exponent = e
+    end
+
+    def clone
+      LargeFloat.new(@mantissa, @exponent)
+    end
+
+    def normalize
+      unless @mantissa == 0
+        normalization = Math.log10(@mantissa.abs).floor
+        @mantissa /= 10**normalization
+        @exponent += normalization
+      end
+    end
+
+    def *(other)
+      if other.instance_of? LargeFloat
+        multiply_with_large_float(other)
+      else
+        multiply_with_numeric(other)
+      end
+    end
+
+    def multiply_with_large_float(lf)
+      product = self * lf.mantissa
+      product.exponent += lf.exponent
+      product
+    end
+
+    def multiply_with_numeric(i)
+      product = clone
+      new_mantissa = product.mantissa * i
+      product.normalize if new_mantissa == Float::INFINITY
+      new_mantissa = product.mantissa * i
+      if new_mantissa == Float::INFINITY
+        product.exponent += 1
+        i /= 10
+      end
+      product.mantissa *= i
+      product
+    end
+
+    def /(other)
+      if other.instance_of? LargeFloat
+        divide_by_large_float(other)
+      else
+        divide_by_numeric(other)
+      end
+    end
+
+    def divide_by_large_float(lf)
+      quotient = self / lf.mantissa
+      quotient.exponent -= lf.exponent
+      quotient
+    end
+
+    def divide_by_numeric(n)
+      quotient = clone
+      quotient.mantissa /= n
+      quotient
+    end
+
+    def new_mantissa_for_addition(lf)
+      @mantissa + lf.mantissa * 10**(lf.exponent - @exponent)
+    end
+
+    def +(other)
+      if self < other
+        other + self
+      else
+        LargeFloat.new(new_mantissa_for_addition(other), @exponent)
+      end
+    end
+
+    def superscript(i)
+      s = i.to_s
+      s = s.gsub(/1/, '¹').gsub(/2/, '²').gsub(/3/, '³').gsub(/4/, '⁴')
+      s = s.gsub(/5/, '⁵').gsub(/6/, '⁶').gsub(/7/, '⁷').gsub(/8/, '⁸')
+      s.gsub(/9/, '⁹').gsub(/0/, '⁰').gsub(/-/, '⁻')
+    end
+
+    def to_s
+      normalize
+      "#{@mantissa}×10#{superscript(@exponent)}"
+    end
+
+    def <=>(other)
+      normalize
+      other.normalize
+      if @exponent == other.exponent
+        @mantissa - other.mantissa
+      else
+        @exponent - other.exponent
+      end
+    end
+  end
+end

data/spec/unit/large_float_spec.rb

@@ -76,6 +76,12 @@ describe LargeBinomials::LargeFloat, '#multiply_by_numeric' do
 		big_number_squared = big_number * 1E+300
 		big_number_squared.exponent.should eq(303)
 	end
+
+	it 'normalizes twice if needed' do
+		big_number = LargeBinomials::LargeFloat.new(2, 3)
+		big_number_squared = big_number * 1E+308
+		big_number_squared.should eq(LargeBinomials::LargeFloat.new(2, 311))
+	end
 	
 	it "doesn't change the exponent of the original LargeFloat in case of overflow" do
 		big_number = LargeBinomials::LargeFloat.new(1E+300, 3)
@@ -185,9 +191,17 @@ describe LargeBinomials::LargeFloat, '#to_s' do
 		10.to_lf.to_s.should eq('1.0×10¹')
 	end
 
+	it 'converts 0.1 to a string as 1.0×10⁻¹' do
+		LargeBinomials::LargeFloat.new(1, -1).to_s.should eq('1.0×10⁻¹')
+	end
+
 	it 'converts 1¹²³⁴⁵⁶⁷⁸⁹⁰ to a string as 1.0×10¹²³⁴⁵⁶⁷⁸⁹⁰' do
 		LargeBinomials::LargeFloat.new(1, 1234567890).to_s.should eq('1.0×10¹²³⁴⁵⁶⁷⁸⁹⁰')
 	end
+
+	it 'converts 1¹²³⁴⁵⁶⁷⁸⁹⁰¹²³⁴⁵⁶⁷⁸⁹⁰ to a string as 1.0×10¹²³⁴⁵⁶⁷⁸⁹⁰¹²³⁴⁵⁶⁷⁸⁹⁰' do
+		LargeBinomials::LargeFloat.new(1, 12345678901234567890).to_s.should eq('1.0×10¹²³⁴⁵⁶⁷⁸⁹⁰¹²³⁴⁵⁶⁷⁸⁹⁰')
+	end
 end
 
 describe LargeBinomials::LargeFloat, '#+' do
@@ -279,3 +293,9 @@ describe LargeBinomials::LargeFloat, '#<=>' do
 		(one < ten).should be_true
 	end
 end
+
+describe LargeBinomials::LargeFloat, '#normalize' do
+  it 'normalizes negative numbers' do
+    -1.to_lf.should eq LargeBinomials::LargeFloat.new(-1, 0)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: large_binomials
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-31 00:00:00.000000000 Z
+date: 2014-06-09 00:00:00.000000000 Z
 dependencies: []
 description: Large binomials
 email: