numbers_in_words 0.0.1

data/README

@@ -0,0 +1,58 @@
+The file numbers_to_words defines a module NumbersToWords which is included in Fixnum and Bignum.
+The in_words method can then be used on any Fixnum or Bignum object.
+
+E.g.
+
+	>112.in_words
+	#=> one hundred and twelve
+
+To try it out the program display_numbers_to_words.rb expects two integer parameters to define a
+range. It then prints out all numbers in words included in this range.
+
+e.g.
+
+	>ruby display_numbers_to_words.rb 1 11
+	one
+	two
+	three
+	four
+	five
+	six
+	seven 
+	eight
+	nine
+	ten
+	eleven
+
+Whilst creating this project I realized that in English:
+
+* Numbers are grouped in groups of threes
+* Numbers less than 1,000 are grouped by hundreds and then by tens
+* There are specific rules for when we put an "and" in between numbers
+
+It makes sense to manage the numbers by these groups, so 
+I created a method groups_of which will split any integer into
+groups of a certain size. It returns a hash with the power of ten
+as the key and the multiplier as the value. E.g:
+
+	> 31245.groups_of(3) 
+	#=>
+	 {0=>245,3=>31} #i.e. 31 thousands, and 245 ones
+
+	> 245.group_of(2)
+	#=>
+	{0=>45,2=>2}    #i.e. 2 hundreds, and 45 ones
+
+I also created a method group_words takes a block and a size parameter 
+This method which could be used by different languages.
+(In Japanese numbers are grouped in groups of 4, so it makes sense to try and
+separate the language related stuff from the number grouping related stuff)
+
+Example of usage:
+	245.group_words(2,"English") do |power, name, digits|
+	   puts "#{digits}*10^#{power} #{digits} #{name}s"
+	end
+
+	2*10^2= 2 hundreds
+	45*10^0 = 45 ones
+

data/lib/numbers_in_words.rb

@@ -0,0 +1,172 @@
+require 'rubygems'
+require 'active_support'
+module NumbersToWords
+
+  #handle exceptions to normal numbers
+  EXCEPTIONS = {10=> "ten", 11=>"eleven", 12 => "twelve", 13 => "thirteen", 
+    14=>"fourteen", 15=>"fifteen", 16=>"sixteen" , 
+    17=> "seventeen", 18=> "eighteen", 19=> "nineteen", 
+    20 => "twenty", 30=>"thirty", 
+    40=>"forty", 50=>"fifty", 60 => "sixty", 70=> "seventy", 80=>"eighty", 
+    90 => "ninety"}
+
+  POWERS_OF_TEN ={0=>"one", 1 => "ten", 2=> "hundred", 
+    3 => "thousand", 6=>"million", 9=>"billion", 12=>"trillion"}
+
+  JAPANESE_POWERS_OF_TEN ={0=>"一", 1 => "十", 2=> "百", 
+    3 => "千", 4=>"万",8=>"億", 12=>"兆"}
+ 
+  DIGITS= %w[zero one two three four five six seven eight nine]
+  JAPANESE_DIGITS= %w[〇 一 二 三 四 五 六 七 八 九]
+
+  #returns a hash with powers of ten and their multipliers
+  def powers_of_ten 
+    i = self.to_i
+    digits=i.to_s.split ""
+    #turn back into integers
+    digits.map! { |x| x.to_i} 
+  
+    digits.reverse!
+    #create a hash where the key is the
+    #power of ten and the value is the multipler
+    power = 0
+    return digits.inject({}) do |result,digit|
+      result[power]=digit unless digit==0
+      power+=1
+      result
+    end
+  end
+
+  def groups_of size
+    i=self.to_i
+    #split into groups this gives us 1234567 => 123 456 7
+    #so we need to reverse first
+    #in stages
+    #i.e. 1234567 => 7654321     
+    groups = i.to_s.reverse
+    #7654321 => 765 432 1
+    groups = groups.split("").in_groups_of(size)
+    #765 432 1 => 1 432 765
+    groups.reverse!
+    #1 432 765 => 1 234 567
+    groups.map! {|group| group.reverse}
+
+    #turn back into integers
+    groups.map! {|group|  group.join("").to_i }
+    groups.reverse! # put in ascending order of power of ten
+    
+    #output hash where key is the power of ten
+    #and value if the multiplier
+    power = 0
+    return groups.inject({}) do |output, digits|
+      output[power]=digits
+      power+=size
+      output
+    end
+
+  end
+
+  def group_words size, language="English"
+    #1000 and over Numbers are split into groups of three
+    number = self.to_i
+    groups = number.groups_of(size)
+    powers = groups.keys.sort.reverse #put in descending order
+    powers.each do |power|
+      name = POWERS_OF_TEN[power] if language=="English"
+      name = JAPANESE_POWERS_OF_TEN[power] if language=="Japanese"
+      digits = groups[power]
+      yield power, name, digits
+    end
+
+  end
+
+  def in_english
+    number = self.to_i # make a copy
+    #handle 0-10
+    return DIGITS[number] if number < 10
+    return EXCEPTIONS[number] if EXCEPTIONS[number]
+
+    output = ""
+    if number.to_s.length == 2 #20-99
+
+      #write the tens
+      tens = (number/10).round*10
+      # e.g. eighty
+      output << EXCEPTIONS[tens]
+
+      #write the digits
+      digit= number - tens
+      output << " " + digit.in_english unless digit==0
+
+    elsif number.to_s.length == 3
+      #e.g. 113 splits into "one hundred" and "thirteen"
+      number.group_words(2) do |power, name, digits|
+        if digits > 0
+          prefix = " "
+          #no and between thousands and hundreds
+          prefix << "and " if power == 0 
+          output << prefix + digits.in_english
+          output << prefix + name if power == 2 #add the hundred
+        end
+      end
+
+    else #more than one hundred
+      number.group_words 3 do |power, name, digits|
+        if digits > 0
+          prefix = " "
+          prefix << "and " if power==0 and digits < 100
+          output << prefix + digits.in_english
+          output << " " + name  unless power==0
+        end
+      end
+    end
+    return output.strip
+  end
+
+  def in_japanese
+    number = self.to_i # make a copy
+    #handle 0-10
+    return DIGITS[number] if number < 10
+    return EXCEPTIONS[number] if EXCEPTIONS[number]
+
+    output = ""
+    if number.to_s.length == 2 #20-99
+
+      #write the tens
+      tens = (number/10).round
+      # e.g. eighty
+      output << JAPANESE_DIGITS[tens] << JAPANESE_POWERS_OF_TEN[1]
+      digit= number - tens
+      output << " " << JAPANESE_DIGITS[digit]
+      #write the digits
+    else #more than one hundred
+      number.group_words 3 do |power, name, digits|
+        if digits > 0
+          prefix = " "
+          prefix << "and " if power==0 and digits < 100
+          output << prefix + digits.in_english
+          output << " " + name  unless power==0
+        end
+      end
+    end
+    return output.strip
+ 
+  end
+
+  def in_words language="English"
+    case language
+    when "English" #allow for I18n
+      in_english
+    when "Japanese"
+      in_japanese
+    end
+  end
+end
+
+class Fixnum
+  include NumbersToWords
+end
+class Bignum
+
+  include NumbersToWords
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: numbers_in_words
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mark Burns
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-31 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: "Use the #in_words method on a Fixnum or Bignum to try it out. Default language is \"English\""
+email: markthedeveloper@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/numbers_in_words.rb
+has_rdoc: true
+homepage: http://github.com/markburns/numbers_in_words
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Turns integers into their long-hand text form like "two thousand and one"
+test_files: []
+