castwide_numbers_in_words 1.0.2

data/lib/numbers_in_words/parsing/fraction_parsing.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  module FractionParsing
+    def fraction(text)
+      return unless possible_fraction?(text)
+
+      NumbersInWords.exceptional_numbers.lookup_fraction(text)
+    end
+
+    def strip_punctuation(text)
+      text.downcase
+          .gsub(/[^a-z 0-9]/, ' ')
+          .gsub(/ +/, ' ')
+    end
+
+    def possible_fraction?(text)
+      words = text.split(' ')
+      result = words & NumbersInWords.exceptional_numbers.fraction_names
+      result.length.positive?
+    end
+
+    def text_including_punctuation
+      to_s.strip
+    end
+
+    def text
+      strip_punctuation text_including_punctuation
+    end
+  end
+end

data/lib/numbers_in_words/parsing/number_parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'parse_fractions'
+require_relative 'parse_status'
+require_relative 'parse_individual_number'
+require_relative 'pair_parsing'
+
+module NumbersInWords
+  class NumberParser
+    # 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
+
+    SCALES_N = [10**2, 10**3, 10**6, 10**9, 10**12, 10**100].freeze
+
+    def parse(nums, only_compress: false)
+      fractions(nums) ||
+        small_numbers(nums, only_compress) ||
+        pair_parsing(nums, only_compress) ||
+        parse_each(nums)
+    end
+
+    private
+
+    def fractions(nums)
+      ParseFractions.new(nums).call
+    end
+
+    # 7 0.066666666666667 => 0.46666666666666
+
+    # 15 => 15
+    def small_numbers(nums, only_compress)
+      return unless nums.length < 2
+      return nums if only_compress
+
+      nums.empty? ? 0 : nums[0]
+    end
+
+    # 15 75 => 1,575
+    def pair_parsing(nums, only_compress)
+      return if (SCALES_N & nums).any?
+
+      pair_parse(nums, only_compress)
+    end
+
+    def parse_each(nums)
+      status = ParseStatus.new
+
+      nums.each do |num|
+        ParseIndividualNumber.new(status, num).call
+      end
+
+      status.calculate
+    end
+
+    def pair_parse(nums, only_compress)
+      PairParsing.new(nums, only_compress).pair_parse
+    end
+  end
+end

data/lib/numbers_in_words/parsing/pair_parsing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class PairParsing
+    attr_accessor :ints
+    attr_reader :only_compress
+
+    def initialize(ints, only_compress)
+      @ints = ints
+      @only_compress = only_compress
+    end
+
+    # 15,16
+    # 85,16
+    def pair_parse
+      ints = compressed
+      return ints if only_compress
+
+      return ints[0] if ints.length == 1
+
+      sum = 0
+
+      ints.each do |n|
+        sum *= n >= 10 ? 100 : 10
+        sum += n
+      end
+
+      sum
+    end
+
+    private
+
+    # [40, 2] => [42]
+    def compressed
+      return [] if ints.empty?
+
+      result = []
+      index = 0
+
+      index, result = compress_numbers(result, index)
+
+      result << ints[-1] if index < ints.length
+
+      result
+    end
+
+    def compress_numbers(result, index)
+      while index < ints.length - 1
+        int, jump = compress_int(ints[index], ints[index + 1])
+        result << int
+        index += jump
+      end
+
+      [index, result]
+    end
+
+    def compress_int(int, next_int)
+      tens = (int % 10).zero? && int > 10
+      return [int + next_int, 2] if tens && next_int < 10
+
+      [int, 1]
+    end
+  end
+end

data/lib/numbers_in_words/parsing/parse_fractions.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class ParseFractions
+    attr_reader :nums
+
+    def initialize(nums)
+      @nums = nums.map(&:to_f)
+    end
+
+    def call
+      return if no_fractions?
+
+      just_fraction || calculate
+    end
+
+    def calculate
+      (parse(numbers) * parse(fractions)).rationalize(EPSILON).to_f
+    end
+
+    def parse(numbers)
+      NumberParser.new.parse(numbers)
+    end
+
+    def numbers
+      nums[0..index_of_fraction - 1]
+    end
+
+    def fractions
+      nums[index_of_fraction..-1]
+    end
+
+    def just_fraction
+      return nums.first if index_of_fraction.zero?
+    end
+
+    def index_of_fraction
+      nums.index { |n| n < 1.0 }
+    end
+
+    def no_fractions?
+      nums.all? { |n| n.zero? || n >= 1.0 }
+    end
+  end
+end

data/lib/numbers_in_words/parsing/parse_individual_number.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class ParseIndividualNumber
+    extend Forwardable
+    def_delegators :parse_status, :reset=, :memory=, :answer=, :reset, :memory, :answer
+
+    attr_reader :parse_status, :num
+
+    def initialize(parse_status, num)
+      @parse_status = parse_status
+      @num = num
+    end
+
+    def call
+      if reset
+        clear
+      else
+        handle_power_of_ten
+
+        update_memory
+      end
+
+      [reset, memory, answer]
+    end
+
+    private
+
+    def clear
+      self.reset = false
+      self.memory += num
+    end
+
+    def handle_power_of_ten
+      # x4. multiply memory by 10^9 because memory < power of ten
+      return unless power_of_ten?(num)
+      return unless power_of_ten(num) > 2
+
+      self.memory *= num
+      # 17. add memory to answer  (and reset) (memory pow of ten > 2)
+      self.answer += memory
+      self.memory = 0
+      self.reset = true
+    end
+
+    def update_memory
+      self.memory = new_memory
+    end
+
+    def new_memory
+      if memory < num
+        memory * num
+      else
+        memory + num
+      end
+    end
+
+    def power_of_ten(integer)
+      Math.log10(integer)
+    end
+
+    def power_of_ten?(integer)
+      return true if integer.zero?
+
+      power_of_ten(integer) == power_of_ten(integer).to_i
+    end
+  end
+end

data/lib/numbers_in_words/parsing/parse_status.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class ParseStatus
+    attr_accessor :reset, :memory, :answer
+
+    def initialize
+      @reset = true
+      @memory = 0
+      @answer = 0
+    end
+
+    def calculate
+      answer + memory
+    end
+  end
+end

data/lib/numbers_in_words/parsing/special.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'fraction_parsing'
+
+module NumbersInWords
+  class Special
+    extend Forwardable
+    def_delegator :that, :to_s
+
+    include FractionParsing
+
+    attr_reader :that, :only_compress
+
+    def initialize(that, only_compress)
+      @that = that
+      @only_compress = only_compress
+    end
+
+    def call
+      float ||
+        negative ||
+        fraction(that) ||
+        mixed_words_and_digits ||
+        one
+    end
+
+    def float
+      text_including_punctuation.to_f if text =~ /^-?\d+(.\d+)?$/
+    end
+
+    def negative
+      stripped = strip_minus text
+      return unless stripped
+
+      stripped_n = NumbersInWords.in_numbers(stripped, only_compress: only_compress)
+      only_compress ? stripped_n.map { |k| k * -1 } : -1 * stripped_n
+    end
+
+    def mixed_words_and_digits
+      return unless numeric?(that)
+
+      in_words = that.split(' ').map { |word| numeric?(word) ? NumbersInWords.in_words(word) : word }.join(' ')
+      ToNumber.new(in_words, only_compress).call
+    end
+
+    def numeric?(word)
+      word.match(/\d+/)
+    end
+
+    def strip_minus(txt)
+      txt.gsub(/^minus/, '') if txt =~ /^minus/
+    end
+
+    def one
+      one = check_one text
+
+      return unless one
+
+      res = NumbersInWords.in_numbers(one[1])
+      only_compress ? [res] : res
+    end
+
+    def check_one(txt)
+      txt.match(/^one (#{POWERS_RX})$/)
+    end
+  end
+end

data/lib/numbers_in_words/parsing/to_number.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'special'
+require_relative 'fraction_parsing'
+
+module NumbersInWords
+  class ToNumber
+    include FractionParsing
+    extend Forwardable
+    def_delegator :that, :to_s
+
+    attr_reader :that, :only_compress
+
+    def initialize(that, only_compress)
+      @that = that
+      @only_compress = only_compress
+    end
+
+    def call
+      special || decimal || as_numbers
+    end
+
+    private
+
+    def special
+      Special.new(that, only_compress).call
+    end
+
+    def decimal
+      match = check_decimal text
+      return unless match
+
+      integer = NumbersInWords.in_numbers(match.pre_match)
+      decimal = NumbersInWords.in_numbers(match.post_match)
+      integer + "0.#{decimal}".to_f
+    end
+
+    def as_numbers
+      numbers = word_array_to_nums text.split(' ')
+
+      NumbersInWords::NumberParser.new.parse numbers, only_compress: only_compress
+    end
+
+    def word_array_to_nums(words)
+      words.map { |i| word_to_num(i) }.compact
+    end
+
+    # handles simple single word numbers
+    # e.g. one, seven, twenty, eight, thousand etc
+    def word_to_num(word)
+      text = canonize(word.to_s.chomp.strip)
+
+      NumbersInWords.exceptional_number(text) || fraction(text) || power(text)
+    end
+
+    def power(text)
+      power = NumbersInWords.power_of_ten(text)
+
+      10**power if power
+    end
+
+    def canonize(word)
+      aliases[word] || word
+    end
+
+    def aliases
+      {
+        'a' => 'one',
+        'oh' => 'zero'
+      }
+    end
+
+    def check_decimal(txt)
+      txt.match(/\spoint\s/)
+    end
+  end
+end

data/lib/numbers_in_words/powers_of_ten.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  GOOGOL = 10**100
+
+  POWERS_OF_TEN = {
+    0 => 'one',
+    1 => 'ten',
+    2 => 'hundred',
+    1 * 3 => 'thousand',
+    2 * 3 => 'million',
+    3 * 3 => 'billion',
+    4 * 3 => 'trillion',
+    5 * 3 => 'quadrillion',
+    6 * 3 => 'quintillion',
+    7 * 3 => 'sextillion',
+    8 * 3 => 'septillion',
+    9 * 3 => 'octillion',
+    10 * 3 => 'nonillion',
+    11 * 3 => 'decillion',
+    12 * 3 => 'undecillion',
+    13 * 3 => 'duodecillion',
+    14 * 3 => 'tredecillion',
+    15 * 3 => 'quattuordecillion',
+    16 * 3 => 'quindecillion',
+    17 * 3 => 'sexdecillion',
+    18 * 3 => 'septendecillion',
+    19 * 3 => 'octodecillion',
+    20 * 3 => 'novemdecillion',
+    21 * 3 => 'vigintillion',
+    22 * 3 => 'unvigintillion',
+    23 * 3 => 'duovigintillion',
+    24 * 3 => 'trevigintillion',
+    25 * 3 => 'quattuorvigintillion',
+    26 * 3 => 'quinvigintillion',
+    27 * 3 => 'sexvigintillion',
+    28 * 3 => 'septenvigintillion',
+    29 * 3 => 'octovigintillion',
+    30 * 3 => 'novemvigintillion',
+    31 * 3 => 'trigintillion',
+    32 * 3 => 'untrigintillion',
+    33 * 3 => 'duotrigintillion',
+    100 => 'googol',
+    101 * 3 => 'centillion',
+    GOOGOL => 'googolplex'
+  }.freeze
+
+  POWERS_RX = Regexp.union(POWERS_OF_TEN.values[1..-1]).freeze
+end

data/lib/numbers_in_words/to_word.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'writer'
+require_relative 'number_group'
+require_relative 'fraction'
+
+module NumbersInWords
+  # Arbitrarily small number for rationalizing fractions
+  EPSILON = 0.0000000001
+
+  class ToWord
+    attr_reader :that
+
+    def initialize(that)
+      @that = that
+    end
+
+    def to_i
+      that.to_i
+    end
+
+    def negative
+      return unless to_i.negative?
+
+      'minus ' + NumbersInWords.in_words(-@that)
+    end
+
+    def in_words(fraction: false)
+      as_fraction(fraction) ||
+        handle_exceptional_numbers ||
+        decimals ||
+        negative ||
+        output
+    end
+
+    def as_fraction(fraction)
+      return Fraction.in_words(that) if fraction
+    end
+
+    def decimals
+      int, decimals = NumberGroup.new(@that).split_decimals
+      return unless int
+
+      out = NumbersInWords.in_words(int) + ' point '
+      decimals.each do |decimal|
+        out = out + NumbersInWords.in_words(decimal.to_i) + ' '
+      end
+      out.strip
+    end
+
+    def output
+      output = if to_i.to_s.length == 2 # 20-99
+                 handle_tens(to_i)
+               else
+                 Writer.new(that).call # longer numbers
+               end
+
+      output.strip
+    end
+
+    def handle_tens(number)
+      output = ''
+
+      tens = (number / 10).round * 10 # write the tens
+
+      output += NumbersInWords.lookup(tens).to_s # e.g. eighty
+
+      digit = number - tens # write the digits
+
+      unless digit.zero?
+        join = number < 100 ? '-' : ' '
+        output = output + join + NumbersInWords.in_words(digit)
+      end
+
+      output
+    end
+
+    def handle_exceptional_numbers
+      return unless @that.is_a?(Integer)
+
+      NumbersInWords.exceptional_numbers.lookup(@that)
+    end
+  end
+end

data/lib/numbers_in_words/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  VERSION = '1.0.2'
+end

data/lib/numbers_in_words/writer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class Writer
+    def initialize(that)
+      @that = that
+    end
+
+    def call
+      length = @that.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 group_words(size)
+      # 1000 and over Numbers are split into groups of three
+      groups = NumberGroup.groups_of @that, size
+      powers = groups.keys.sort.reverse # put in descending order
+
+      powers.each do |power|
+        name = NumbersInWords::POWERS_OF_TEN[power]
+        digits = groups[power]
+        yield power, name, digits
+      end
+    end
+
+    private
+
+    def write_googols
+      googols, remainder = NumberGroup.new(@that).split_googols
+      output = ''
+
+      output = output + ' ' + NumbersInWords.in_words(googols) + ' googol'
+      if remainder.positive?
+        prefix = ' '
+        prefix += 'and ' if remainder < 100
+        output = output + prefix + NumbersInWords.in_words(remainder)
+      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.positive?
+          prefix = ' '
+          # no and between thousands and hundreds
+          prefix += 'and ' if power.zero? && (digits < 100)
+          output = output + prefix + NumbersInWords.in_words(digits)
+          output = output + prefix + name unless power.zero?
+        end
+      end
+      output
+    end
+  end
+end