numbers_in_words 0.1.0 → 0.1.1

data/Manifest

@@ -7,6 +7,5 @@ init.rb
 lib/numbers.rb
 lib/numbers_in_words.rb
 lib/words.rb
-numbers_in_words.gemspec
 spec/numbers_in_words_spec.rb
 spec/words_in_numbers_spec.rb

data/README

@@ -1,7 +1,6 @@
 Installation
 ============
 
-
 gem install numbers_in_words
 
 or 
@@ -10,13 +9,21 @@ 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 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.
@@ -68,3 +75,10 @@ Example of usage:
 	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/Rakefile

@@ -1,14 +1,44 @@
 require 'rubygems'
 require 'rake'
 require 'echoe'
-Echoe.new('numbers_in_words','0.1.0') do |e|
+require 'metric_fu'
+
+Echoe.new('numbers_in_words','0.1.1') do |e|
   e.description = "#in_words method for integers and #in_numbers for strings"
   e.summary = "Example: 123.in_words #=> \"one hundred and twenty three\", \"seventy-five point eight\".in_numbers #=> 75.8"
   e.url = "http://rubygems.org/gems/numbers_in_words"
   e.author = "Mark Burns"
-  e.email = "markthedeveloper@googlemail.com"
+  e.email = "markthedeveloper@gmail.com"
   e.ignore_pattern = ["tmp/*",".git/*"]
-  e.development_dependencies = ['active_support']
+  e.dependencies = ['active_support']
 end
 
 
+MetricFu::Configuration.run do |config|
+  #define which metrics you want to use
+  config.metrics  = [:churn, :saikuro, :stats, :flog, :flay, :reek, :roodi, :rcov]
+  config.graphs   = [:flog, :flay, :reek, :roodi, :rcov]
+  config.flay     = { :dirs_to_flay => ['lib'],    :minimum_score => 100  }
+  config.flog     = { :dirs_to_flog => [ 'lib']  }
+  config.reek     = { :dirs_to_reek => ['lib']  }
+  config.roodi    = { :dirs_to_roodi => ['lib'] }
+  config.saikuro  = { :output_directory => 'scratch_directory/saikuro',
+                      :input_directory => ['lib'],
+                      :cyclo => "",
+                      :filter_cyclo => "0",
+                      :warn_cyclo => "5",
+                      :error_cyclo => "7",
+                      :formater => "text"} #this needs to be set to "text"
+  config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
+  config.rcov     = { :environment => 'test',
+                      :test_files => ['spec/**/*_spec.rb'],
+                      :rcov_opts => ["--sort coverage",
+                                     "--no-html",
+                                     "--text-coverage",
+                                     "--no-color",
+                                     "--profile",
+                                     "--rails",
+                                     "--exclude /gems/,/Library/,spec"]}
+  config.graph_engine = :bluff
+end
+

data/lib/numbers.rb

@@ -1,237 +1,260 @@
 require 'rubygems'
-require 'active_support'
+require 'active_support/core_ext/array'
 module NumbersInWords
+  EXCEPTIONS = {
+    10 => "ten",
+    11 => "eleven",
+    12 => "twelve",
 
-  #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"}
-
-  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"
+    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 initialize
-    power = 9
-    POWERS_OF_TEN_NAMES.each do |name|
-      POWERS_OF_TEN[power]=name
-      power += 3
+  def in_words language="English"
+    case language
+    when "English" #allow for I18n
+      in_english
     end
   end
 
-  #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 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]
 
-  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
+    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
 
-  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"
-      digits = groups[power]
-      yield power, name, digits
+  protected
+
+  class LanguageWriter
+    attr_accessor :number
+
+    def initialize number
+      @number = number
     end
 
-  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
 
-  def english_group group_size
-    number = self.to_i
-    output = ""
-    number.group_words(group_size) 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
+      powers.each do |power|
+        name = POWERS_OF_TEN[power]
+        digits = groups[power]
+        yield power, name, digits
       end
     end
-    return output
   end
 
-  def split_googols
-    number = self.to_i
-    output = ""
-    googols = number.to_s[0..(-LENGTH_OF_GOOGOL)].to_i
-    remainder = number.to_s[1-LENGTH_OF_GOOGOL .. -1].to_i
-    output << " " + googols.in_words + " googol" 
-    if remainder > 0
-      prefix = " "
-      prefix << "and " if remainder < 100
-      output << prefix + remainder.in_english
+  class LanguageWriterEnglish < LanguageWriter
+    def negative
+      "minus " + (-@number).in_english
     end
-    return output
-  end
 
-  def in_googols
+    def write
+      length = @number.to_s.length
+      output = if length == 3
+                 #e.g. 113 splits into "one hundred" and "thirteen"
+                 write_groups(2)
 
-    number = self.to_i
-    output = ""
-    output << " " + number.to_s[0..0].to_i.in_english + " googol"
-    remainder = number.to_s[1..-1].to_i
-    prefix = " "
-    prefix << "and " if remainder < 100
-    output << prefix + remainder.in_english if remainder > 0
+                 #more than one hundred less than one googol
+               elsif length < LENGTH_OF_GOOGOL
+                 write_groups(3)
 
-    return output
-  end
+               elsif length >= LENGTH_OF_GOOGOL
+                 write_googols
 
-  def handle_decimal value
-    if value.is_a? Float
-      int = value.to_i
-      decimal = value - int
-      return int.in_english + " point " + decimal_portion(decimal)
+               end
+      output.strip
     end
-    return nil
-  end
 
-  def decimal_portion decimal
-    decimal = decimal.to_s.split(".")[1]
-    digits = decimal.to_s.split //
-    out= digits.inject([]) {|out, digit|
-      out<< digit.to_i.in_english
-      out
-    }
-    out.join " "
+    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
 
-  def in_english
-    #decimals
-    d= handle_decimal(self)
-    return d unless d.nil?
+  class NumberGroup
+    include Enumerable
+    attr_accessor :number
 
+    def each
+      @array.each { |item|  yield item}
+    end
 
-    number = self.to_i # make a copy
-    #negative numbers
-    return "minus " + (-number).in_english if number < 0
+    #split into groups this gives us 1234567 => 123 456 7
+    #so we need to reverse first
+    #in stages
+    def initialize number
+      @number = number
+    end
 
-    #handle 0-10
-    return DIGITS[number] if number < 10
-    return EXCEPTIONS[number] if EXCEPTIONS[number]
+    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
 
-    #longer numbers
-    output = ""
-    length = number.to_s.length
-    if length == 2 #20-99
-      tens = (number/10).round*10 #write the tens
-      # e.g. eighty
-      output << EXCEPTIONS[tens]
-      #write the digits
-      digit= number - tens
-      output << " " + digit.in_english unless digit==0
-    elsif length == 3
-      #e.g. 113 splits into "one hundred" and "thirteen"
-      output << number.english_group(2)
-    elsif length < LENGTH_OF_GOOGOL #more than one hundred less than one googol
-      output << number.english_group(3)
-    elsif length == LENGTH_OF_GOOGOL 
-      output << number.in_googols
-    elsif length > LENGTH_OF_GOOGOL #one googol and larger
-      output << number.split_googols
+    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
 
-    return output.strip
-  end
+    def self.groups_of number, size
+      new(number).groups(size)
+    end
 
-  def in_words language="English"
-    case language
-    when "English" #allow for I18n
-      in_english
+    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 Fixnum
-  include NumbersInWords
-end
-
-class Bignum
-  include NumbersInWords
-end
 
-class Float
+class Numeric
   include NumbersInWords
 end

data/lib/numbers_in_words.rb

@@ -5,4 +5,3 @@ $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
 require 'numbers'
 require 'words'
 
-