numerals 0.0.0 → 0.1.0

data/lib/numerals/format/notations/text.rb

@@ -0,0 +1,141 @@
+module Numerals
+
+  class Format
+
+    class TextNotation < Notation
+
+      def assemble(output, text_parts)
+        if text_parts.special?
+          output << text_parts.special
+        else
+          output << text_parts.sign
+          output << text_parts.integer # or decide here if empty integer part is show as 0?
+          unless !text_parts.fractional? &&
+                 !text_parts.repeat? &&
+                 !format.symbols.show_point
+            output << format.symbols.point
+          end
+          output << text_parts.fractional
+          if text_parts.repeat?
+            if format.symbols.repeat_delimited
+              output << format.symbols.repeat_begin
+              output << text_parts.repeat
+              output << format.symbols.repeat_end
+            else
+              n = RepeatDetector.min_repeat_count(
+                    text_parts.numeral.digits.digits_array,
+                    text_parts.numeral.repeat,
+                    format.symbols.repeat_count - 1
+                  )
+              n.times do
+                output << text_parts.repeat
+              end
+              output << format.symbols.repeat_suffix
+            end
+          end
+          if text_parts.exponent_value != 0 || format.mode.mode == :scientific
+            output << format.symbols.exponent
+            output << text_parts.exponent
+          end
+        end
+      end
+
+      def disassemble(text)
+        text_parts = TextParts.new
+        s = format.symbols
+        special = /
+          \A
+          #{s.regexp(:plus, :minus, case_sensitivity: true)}?
+          \s*
+          #{s.regexp(:nan, :infinity, case_sensitivity: true)}
+          \Z
+        /x
+        if match = special.match(text)
+          valid = true
+          text_parts.special = "#{match[1]}#{match[2]}"
+        else
+          valid = true
+          base = format.significand_base
+          # TODO: replace numbered groups by named variables ?<var>
+          # TODO: ignore padding, admit base indicators
+          regular = /
+            \A
+            #{s.regexp(:plus, :minus)}?
+            \s*
+            (?:
+              (?:(#{s.regexp(:grouped_digits, base: base, no_capture: true)}+)#{s.regexp(:point)}?)
+              |
+              #{s.regexp(:point)} # admit empty integer part, but then a point is needed
+            )
+            (#{s.regexp(:digits, base: base, no_capture: true)}*)
+            (?:#{s.regexp(:repeat_begin)}(#{s.regexp(:digits, base: base, no_capture: true)}+)#{s.regexp(:repeat_end)})?
+            #{s.regexp(:repeat_suffix)}?
+            (?:#{s.regexp(:exponent)}#{s.regexp(:plus, :minus)}?(\d+))?
+            \Z
+          /x
+          unless s.case_sensitive?
+            regular = Regexp.new(regular.source, regular.options | Regexp::IGNORECASE)
+          end
+
+          match = regular.match(text)
+
+          if match.nil?
+            valid = false
+          else
+            # TODO: we could avoid capturing point, point_with_no_integer_part
+            sign = match[1]
+            integer_part = match[2]
+            point = match[3]
+            point_with_no_integer_part = match[4]
+            fractional_part = match[5]
+            repeat_begin = match[6]
+            repeat_part = match[7]
+            repeat_end = match[8]
+            repeat_suffix = match[9]
+            exponent = match[10]
+            exponent_sign = match[11]
+            exponent_value = match[12]
+
+            text_parts.sign = sign
+            text_parts.integer = integer_part
+            text_parts.fractional = fractional_part
+
+            if repeat_begin
+              if !repeat_part || !repeat_end || repeat_suffix
+                valid = false
+              end
+              text_parts.repeat = repeat_part
+            else
+              if repeat_part || repeat_end
+                valid = false
+              end
+              if repeat_suffix
+                text_parts.detect_repeat = true
+              end
+            end
+
+            text_parts.exponent_base = format.base
+            if exponent
+              if !exponent_value
+                valid = false
+              end
+              text_parts.exponent = "#{exponent_sign}#{exponent_value}"
+              text_parts.exponent_value = text_parts.exponent.to_i
+            else
+              if exponent_sign || exponent_value
+                valid = false
+              end
+            end
+          end
+        end
+        raise "Invalid text numeral" unless valid
+        text_parts
+      end
+
+    end
+
+    define_notation :text, TextNotation
+
+  end
+
+end

data/lib/numerals/format/output.rb

@@ -0,0 +1,167 @@
+require 'stringio'
+
+module Numerals
+
+  # Formatted output implementation
+  module Format::Output
+
+    def write(number, options={})
+      # 1. Convert number to numeral
+      numeral = conversion_out(number)
+      if numeral.approximate? && !@rounding.free?
+        insignificant_digits = @rounding.precision(numeral) - numeral.digits.size
+        if insignificant_digits > 0
+          numeral.expand! @rounding.precision(numeral)
+        end
+      end
+      return numeral if options[:output] == :numeral
+      # 2. Break numeral into parts (digits, etc.)
+      num_parts = partition_out(numeral, insignificant_digits: insignificant_digits)
+      if !@symbols.repeating && num_parts.repeating?
+        raise Format::InvalidRepeatingNumeral, "Invalid format: cannot represent exact value"
+      end
+      # 3. Represent parts as text
+      text_parts = symbolize_out(num_parts)
+      # 4. Assemble text parts into output notation
+      output = options[:output] || StringIO.new
+      assemble_out(output, text_parts)
+      options[:output] ? output : output.string
+    end
+
+    private
+
+    def digits_text(part, options = {})
+      @symbols.digits_text(part, options)
+    end
+
+    def grouped_digits_text(part, options = {})
+      @symbols.digits_text(part, options.merge(with_grouping: true))
+    end
+
+    def conversion_out(number) # => Numeral
+      return number if number.kind_of?(Numeral) # @exact_input is ignored
+      conversion_options = {
+        exact: exact_input,
+        rounding: rounding,
+        type_options: {
+          input_rounding: input_rounding_mode
+        }
+      }
+      Conversions.write(number, conversion_options)
+    end
+
+    def partition_out(numeral, options={}) # => num_parts (ExpSetting/BaseScaler)
+      num_parts = Format::ExpSetter[numeral, options]
+      return num_parts if numeral.special?
+      mode = @mode.mode
+      if mode == :general
+        mode = :fixed
+        if @mode.max_leading == :all
+          if numeral.repeating?
+            max_leading = 0
+          else
+            max_leading = @rounding.precision(numeral) - numeral.digits.size
+          end
+        else
+          max_leading = @mode.max_leading
+        end
+        check_trailing = !numeral.repeating?
+        if num_parts.leading_size > max_leading ||
+           check_trailing && (num_parts.trailing_size > @mode.max_trailing)
+          mode = :scientific
+        end
+      end
+
+      case mode
+      when :fixed
+        num_parts.exponent = 0
+      when :scientific
+        if @mode.sci_int_digits == :engineering
+          num_parts.integer_part_size = 1
+          num_parts.integer_part_size += 1 while (num_parts.exponent % 3) != 0
+        elsif @mode.sci_int_digits == :all
+          raise "Cannot represent number with integral significand" if numeral.repeating?
+          num_parts.integer_part_size = numeral.digits.size
+        else
+          num_parts.integer_part_size = @mode.sci_int_digits
+        end
+      end
+      if @mode.base_scale > 1 && !num_parts.special?
+        num_parts = Format::BaseScaler[num_parts, @mode.base_scale]
+      end
+
+      num_parts
+    end
+
+    def symbolize_out(num_parts) # => text_parts Hash
+      text_parts = TextParts.new(num_parts.numeral)
+      if num_parts.special?
+        case num_parts.special
+        when :nan
+          text_parts.special = @symbols.nan
+        when :inf
+          if num_parts.sign == -1
+            text_parts.special = @symbols.negative_infinity
+          else
+            text_parts.special = @symbols.positive_infinity
+          end
+        end
+      else
+        if num_parts.sign == -1
+          text_parts.sign = @symbols.minus
+        elsif @symbols.show_plus
+          text_parts.sign = @symbols.plus
+        end
+        if num_parts.integer_part.empty?
+          if @symbols.show_zero || (num_parts.fractional_part.empty? && !num_parts.repeat_part.empty?)
+            text_parts.integer = @symbols.zero
+          end
+          text_parts.integer_value = 0
+        else
+          if @symbols.insignificant_digit.nil?
+            # we can't just omit integer part symbols
+            integer_insignificant_digits = 0
+          else
+            integer_insignificant_digits = num_parts.integer_insignificant_size
+          end
+          text_parts.integer = grouped_digits_text(
+                                 num_parts.integer_part,
+                                 insignificant_digits: integer_insignificant_digits,
+                                 base: num_parts.base
+                               )
+          text_parts.integer_value = Numerals::Digits[num_parts.integer_part, base: num_parts.base].value
+        end
+        text_parts.fractional = digits_text(
+                                  num_parts.fractional_part,
+                                  insignificant_digits: num_parts.fractional_insignificant_size,
+                                  baseL: num_parts.base
+                                )
+        if num_parts.repeating?
+          text_parts.repeat = digits_text(
+                                num_parts.repeat_part,
+                                insignificant_digits: num_parts.repeat_insignificant_size,
+                                base: num_parts.base
+                              )
+        end
+        text_parts.exponent_value = num_parts.exponent
+        # if num_parts.exponent != 0 || @mode.mode == :scientific
+          text_parts.exponent = num_parts.exponent.to_s(10) # use digits_definition ?
+          if @symbols.show_exponent_plus && num_parts.exponent >= 0
+            text_parts.exponent = @symbols.plus + text_parts.exponent
+          end
+        # end
+        text_parts.exponent_base = num_parts.exponent_base.to_s(10) # use digits_definition ?
+        text_parts.exponent_base_value = num_parts.exponent_base
+      end
+      # TODO: justification
+      # TODO: base indicator for significand? significand_bas?
+      text_parts
+    end
+
+    def assemble_out(output, text_parts)
+      Format.assemble(@notation, output, self, text_parts)
+    end
+
+  end
+
+end