numbers_in_words 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1 +0,0 @@
-v0.1.0. Handles decimals

data/Manifest

@@ -1,11 +0,0 @@
-CHANGELOG
-Manifest
-README
-Rakefile
-examples/display_numbers_in_words.rb
-init.rb
-lib/numbers.rb
-lib/numbers_in_words.rb
-lib/words.rb
-spec/numbers_in_words_spec.rb
-spec/words_in_numbers_spec.rb

data/README

@@ -1,84 +0,0 @@
-Installation
-============
-
-gem install numbers_in_words
-
-or 
-
-sudo gem install numbers_in_words
-
-
-
-
-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.
-	>require 'numbers_in_words'
-	>112.in_words
-	 => one hundred and twelve
-	>"one googol".in_numbers
-	 =>10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 
-        >"Seventy million, five-hundred and fifty six thousand point eight nine three".in_numbers
-         => 70556000.893
-
----------------
-Example program
-
-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
-
-Future plans
-============
-
-* Handle complex numbers
-* Option for outputting punctuation
-* Reject invalid numbers
-* Support for other languages

data/examples/display_numbers_in_words.rb

@@ -1,22 +0,0 @@
-require 'rubygems'
-require 'numbers_in_words'
-def usage code=-1
-  puts "\nUsage:\n\nruby #{__FILE__} <start> <end>"
-  exit code
-end
-if ARGV.length != 2
-
-  puts "Start and end arguments expected"
-  usage -1
-end
-start_number = ARGV[0].to_i
-end_number = ARGV[1].to_i
-
-if start_number > end_number
-  puts "Start number must be less than or equal to the end number"
-  usage -2
-end
-
-for i in start_number..end_number do
-  puts i.in_words
-end

data/init.rb

@@ -1,8 +0,0 @@
-require 'rubygems'
-
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
-
-require 'lib/numbers_in_words'
-require 'lib/words_in_numbers'
-
-

data/lib/numbers.rb

@@ -1,260 +0,0 @@
-require 'rubygems'
-require 'active_support/core_ext/array'
-module NumbersInWords
-  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"
-  }
-
-  DIGITS = %w[zero one two three four five six seven eight nine]
-
-  POWERS_OF_TEN ={
-    0   => "one",
-    1   => "ten",
-    2   => "hundred",
-    3   => "thousand",
-    6   => "million",
-    9   => "billion",
-    12  => "trillion",
-    15  => "quadrillion",
-    18  => "quintillion",
-    21  => "sextillion",
-    24  => "septillion",
-    27  => "octillion",
-    30  => "nonillion",
-    33  => "decillion",
-    36  => "undecillion",
-    39  => "duodecillion",
-    42  => "tredecillion",
-    45  => "quattuordecillion",
-    48  => "quindecillion",
-    51  => "sexdecillion",
-    54  => "septendecillion",
-    57  => "octodecillion",
-    60  => "novemdecillion",
-    63  => "vigintillion",
-    66  => "unvigintillion",
-    69  => "duovigintillion",
-    72  => "trevigintillion",
-    75  => "quattuorvigintillion",
-    78  => "quinvigintillion",
-    81  => "sexvigintillion",
-    84  => "septenvigintillion",
-    87  => "octovigintillion",
-    90  => "novemvigintillion",
-    93  => "trigintillion",
-    96  => "untrigintillion",
-    99  => "duotrigintillion",
-    100 => "googol"
-    }
-
-  LENGTH_OF_GOOGOL = 101 #length of the string i.e. one with 100 zeros
-
-  def in_words language="English"
-    case language
-    when "English" #allow for I18n
-      in_english
-    end
-  end
-
-  def in_english
-    #handle 0-9
-    return DIGITS[self]     if self.is_a?(Integer) and (0..9).to_a.include? self
-    #teens etc
-    return EXCEPTIONS[self] if self.is_a?(Integer) and EXCEPTIONS[self]
-
-    writer = LanguageWriterEnglish.new(self)
-
-    in_decimals = writer.decimals
-    return in_decimals unless in_decimals.nil?
-
-    number = to_i
-
-    return writer.negative() if number < 0
-
-    length = number.to_s.length
-    output = ""
-
-    if length == 2 #20-99
-      tens = (number/10).round*10 #write the tens
-
-      output << EXCEPTIONS[tens] # e.g. eighty
-
-      digit = number - tens       #write the digits
-
-      output << " " + digit.in_english unless digit==0
-    else
-      output << writer.write() #longer numbers
-    end
-
-    output.strip
-  end
-
-  protected
-
-  class LanguageWriter
-    attr_accessor :number
-
-    def initialize number
-      @number = number
-    end
-
-    def group_words size
-      #1000 and over Numbers are split into groups of three
-      groups = NumberGroup.groups_of @number, size
-      powers = groups.keys.sort.reverse #put in descending order
-
-      powers.each do |power|
-        name = POWERS_OF_TEN[power]
-        digits = groups[power]
-        yield power, name, digits
-      end
-    end
-  end
-
-  class LanguageWriterEnglish < LanguageWriter
-    def negative
-      "minus " + (-@number).in_english
-    end
-
-    def write
-      length = @number.to_s.length
-      output = if length == 3
-                 #e.g. 113 splits into "one hundred" and "thirteen"
-                 write_groups(2)
-
-                 #more than one hundred less than one googol
-               elsif length < LENGTH_OF_GOOGOL
-                 write_groups(3)
-
-               elsif length >= LENGTH_OF_GOOGOL
-                 write_googols
-
-               end
-      output.strip
-    end
-
-    def decimals
-      int, decimals = NumberGroup.new(@number).split_decimals
-      if int
-        out = int.in_english + " point "
-        decimals.each do |decimal|
-          out << decimal.to_i.in_english + " "
-        end
-        out.strip
-      end
-    end
-
-    private
-    def write_googols
-      googols, remainder = NumberGroup.new(@number).split_googols
-      output = ""
-      output << " " + googols.in_words + " googol"
-      if remainder > 0
-        prefix = " "
-        prefix << "and " if remainder < 100
-        output << prefix + remainder.in_english
-      end
-      output
-    end
-
-    def write_groups group
-      #e.g. 113 splits into "one hundred" and "thirteen"
-      output = ""
-      group_words(group) do |power, name, digits|
-        if digits > 0
-          prefix = " "
-          #no and between thousands and hundreds
-          prefix << "and " if power == 0  and digits < 100
-          output << prefix + digits.in_english
-          output << prefix + name unless power == 0
-        end
-      end
-      output
-    end
-  end
-
-  class NumberGroup
-    include Enumerable
-    attr_accessor :number
-
-    def each
-      @array.each { |item|  yield item}
-    end
-
-    #split into groups this gives us 1234567 => 123 456 7
-    #so we need to reverse first
-    #in stages
-    def initialize number
-      @number = number
-    end
-
-    def groups size
-      #i.e. 1234567 => 7654321
-      groups = @number.to_s.reverse
-      #7654321 => 765 432 1
-      @array = groups.split("").in_groups_of(size)
-      #765 432 1 => 1 432 765
-      @array.reverse!
-      #1 432 765 => 1 234 567
-      #and turn back into integers
-      @array.map! {|group| group.reverse.join("").to_i}
-      @array.reverse! # put in ascending order of power of ten
-      power = 0
-      output = @array.inject({}) do |output, digits|
-        output[power] = digits
-        power += size
-        output
-      end
-      output
-    end
-
-    def split_decimals
-      if @number.is_a? Float
-        int     = @number.to_i
-        decimal = @number - int
-        decimal = decimal.to_s.split(".")[1]
-        digits  = decimal.split //
-          #convert to integers array
-          digits.inject([]) {|out, digit|
-          out<< digit.to_i
-        }
-        return int, digits
-      end
-    end
-
-    def self.groups_of number, size
-      new(number).groups(size)
-    end
-
-    def split_googols
-      output    = ""
-      googols   = @number.to_s[0  ..  (-LENGTH_OF_GOOGOL)].to_i
-      remainder = @number.to_s[(1-LENGTH_OF_GOOGOL) .. -1].to_i
-      return googols, remainder
-    end
-  end
-end
-
-
-class Numeric
-  include NumbersInWords
-end

data/lib/words.rb

@@ -1,221 +0,0 @@
-module WordsInNumbers
-  def in_numbers
-    text = to_s
-
-    WordToNumber.new.instance_eval do
-      text = strip_punctuation text
-      #negative numbers
-      return -1 * (text.gsub(/^minus /, "")).in_numbers if text =~ /^minus /
-
-      #easy single word case
-      word = word_to_integer(text)
-      return word unless word.nil?
-
-      #decimals
-      match = text.match(/\spoint\s/)
-      if match
-        integer = match.pre_match.in_numbers
-
-        decimal = decimal_portion match.post_match
-
-        return integer + decimal
-      end
-
-      #multiple word case
-      words = text.split " "
-      integers = word_array_to_integers words
-
-      integer= parse_numbers(integers)
-      return integer unless integer.nil?
-      return nil
-    end
-  end
-
-  class WordToNumber
-    DIGITS= %w[zero one two three four five six seven eight nine]
-
-    EXCEPTIONS = {
-      "ten"          => 10,
-      "eleven"       => 11,
-      "twelve"       => 12,
-      "thirteen"     => 13,
-      "fourteen"     => 14,
-      "fifteen"      => 15,
-      "sixteen"      => 16,
-      "seventeen"    => 17,
-      "eighteen"     => 18,
-      "nineteen"     => 19,
-      "twenty"       => 20,
-      "thirty"       => 30,
-      "forty"        => 40,
-      "fifty"        => 50,
-      "sixty"        => 60,
-      "seventy"      => 70,
-      "eighty"       => 80,
-      "ninety"       => 90
-    }
-
-
-    POWERS_OF_TEN ={
-      "one"                  => 0,
-      "ten"                  => 1 ,
-      "hundred"              => 2,
-      "thousand"             => 3 ,
-      "million"              => 6,
-      "billion"              => 9,
-      "trillion"             => 12,
-      "quadrillion"          => 15,
-      "quintillion"          => 18,
-      "sextillion"           => 21,
-      "septillion"           => 24,
-      "octillion"            => 27,
-      "nonillion"            => 30,
-      "decillion"            => 33,
-      "undecillion"          => 36,
-      "duodecillion"         => 39,
-      "tredecillion"         => 42,
-      "quattuordecillion"    => 45,
-      "quindecillion"        => 48,
-      "sexdecillion"         => 51,
-      "septendecillion"      => 54,
-      "octodecillion"        => 57,
-      "novemdecillion"       => 60,
-      "vigintillion"         => 63,
-      "unvigintillion"       => 66,
-      "duovigintillion"      => 69,
-      "trevigintillion"      => 72,
-      "quattuorvigintillion" => 75,
-      "quinvigintillion"     => 78,
-      "sexvigintillion"      => 81,
-      "septenvigintillion"   => 84,
-      "octovigintillion"     => 87,
-      "novemvigintillion"    => 90,
-      "trigintillion"        => 93,
-      "untrigintillion"      => 96,
-      "duotrigintillion"     => 99,
-      "googol"               => 100
-    }
-
-    def strip_punctuation text
-      text = text.downcase.gsub /[^a-z ]/, " "
-      to_remove = true
-
-      to_remove = text.gsub! "  ", " " while to_remove
-
-      text
-    end
-
-    def decimal_portion text
-      words = text.split " "
-      integers = word_array_to_integers words
-      decimal = "0." + integers.join()
-      decimal.to_f
-    end
-
-
-    private
-
-    # Example: 364,895,457,898
-    #three hundred and sixty four billion eight hundred and ninety five million
-    #four hundred and fifty seven thousand eight hundred and ninety eight
-    #
-    #3 100 60 4 10^9, 8 100 90 5 10^6, 4 100 50 7 1000, 8 100 90 8
-    #                                                                    memory answer
-    #x1. 3 add to memory because answer and memory are zero                 3     0
-    #x2. memory * 100 (because memory<100)                                  300   0
-    #x3. 60 add to memory because memory > 60                               360   0
-    #x3. 4 add to memory because memory > 4                                364    0
-    #x4. multiply memory by 10^9 because memory < power of ten          364*10^9  0
-    #x5. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364*10^9
-    #x6. 8 add to memory because not finished                                8    ''
-    #x7. multiply memory by 100 because memory < 100                        800   ''
-    #x8. add 90 to memory because memory > 90                               890   ''
-    #x9. add 5 to memory because memory > 5                                 895   ''
-    #x10. multiply memory by 10^6 because memory < power of ten        895*10^6    ''
-    #x11. add memory to answer (and reset) because memory power ten > 2       0    364895 * 10^6
-    #x12. 4 add to memory because not finished                                4    ''
-    #x13. memory * 100 because memory < 100                                 400    ''
-    #x14. memory + 50 because memory > 50                                   450    ''
-    #x15. memory + 7  because memory > 7                                    457    ''
-    #x16. memory * 1000 because memory < 1000                            457000    ''
-    #x17. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364895457000
-    #x18. 8 add to memory because not finished                                8    ''
-    #x19. memory * 100 because memory < 100                                 800    ''
-    #x14. memory + 90 because memory > 90                                   890    ''
-    #x15. memory + 8  because memory > 8                                    898    ''
-    #16. finished so add memory to answer
-
-    #Example
-    #2001
-    #two thousand and one
-    #2 1000 1
-    #                                                                memory answer
-    #1. add 2 to memory because first                                  2       0
-    #2. multiply memory by 1000 because memory < 1000                2000      0
-    #3. add memory to answer,reset,  because power of ten>2            0      2000
-    #4. add 1 to memory                                                1      2000
-    #5. finish - add memory to answer                                  0      2001
-    def parse_numbers(integers)
-      memory = 0
-      answer = 0
-      reset = true #reset each time memory is reset
-      integers.each_with_index do |integer, index|
-        if reset
-          reset = false
-          memory += integer
-        else
-          #x4. multiply memory by 10^9 because memory < power of ten
-          if is_power_of_ten?(integer)
-            if power_of_ten(integer)> 2
-              memory *= integer
-              #17. add memory to answer  (and reset) (memory pow of ten > 2)
-              answer += memory
-              memory = 0
-              reset = true
-            end
-          end
-
-          if memory < integer
-            memory *= integer
-          else
-            memory += integer
-          end
-        end
-      end
-      answer += memory
-    end
-
-    def power_of_ten integer
-      Math.log10(integer)
-    end
-
-    def is_power_of_ten? integer
-      power_of_ten(integer)==power_of_ten(integer).to_i
-    end
-
-    #handles simple single word numbers
-    #e.g. one, seven, twenty, eight, thousand etc
-    def word_to_integer word
-      text = word.to_s.chomp.strip
-      #digits 0-9
-      digit = DIGITS.index(text)
-      return digit unless digit.nil?
-
-      #digits which are exceptions
-      exception = EXCEPTIONS[text]
-      return exception unless exception.nil?
-
-      power = POWERS_OF_TEN[text]
-      return 10**power unless power.nil?
-    end
-
-    def word_array_to_integers words
-      words.map { |i| word_to_integer i }.compact
-    end
-  end
-end
-
-class String
-  include WordsInNumbers
-end
-