plurimath 0.11.0 → 0.11.3

data/lib/plurimath/formatter/numbers/mathml_renderer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Renders a Formatter result (FormattedNotation, FormattedNumber, or
+      # String) into a MathML element tree. Number delegates to this so the
+      # model does not carry format-specific XML construction.
+      module MathmlRenderer
+        module_function
+
+        def render(result)
+          case result
+          when FormattedNotation then render_notation(result)
+          when FormattedNumber
+            result.base_notation.semantic? ? render_semantic_base(result) : plain_element(result)
+          else
+            plain_element(result)
+          end
+        end
+
+        def render_notation(notation)
+          return plain_element(notation) if notation.notation_style == :e
+
+          coeff = plain_element(notation.coefficient)
+          times = Utility.ox_element("mo") << notation.times_symbol.to_s
+          base_el = Utility.ox_element("mn") << "10"
+          exp_el = Utility.ox_element("mn") << notation.formatted_exponent
+          sup = Utility.ox_element("msup")
+          Utility.update_nodes(sup, [base_el, exp_el])
+          row = Utility.ox_element("mrow")
+          Utility.update_nodes(row, [coeff, times, sup])
+          row
+        end
+
+        def render_semantic_base(formatted)
+          digits = Utility.ox_element("mn") << formatted.digits_string
+          base_el = Utility.ox_element("mn") << formatted.base_notation.base.to_s
+          sub = Utility.ox_element("msub")
+          Utility.update_nodes(sub, [digits, base_el])
+
+          return sub unless formatted.sign_text
+
+          sign_el = Utility.ox_element("mo") << formatted.sign_text
+          row = Utility.ox_element("mrow")
+          Utility.update_nodes(row, [sign_el, sub])
+          row
+        end
+
+        def plain_element(result)
+          Utility.ox_element("mn") << result.to_s
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers/notation_renderer.rb

@@ -11,7 +11,6 @@ module Plurimath
         def initialize(options)
           @options = options
           @precision = (@options.precision || 0).to_i
-          @exponent_sign_renderer = SignRenderer.new(@options.exponent_sign)
         end
 
         def render(source, notation)
@@ -31,21 +30,43 @@ module Plurimath
 
         private
 
-        attr_reader :exponent_sign_renderer, :options, :precision
+        attr_reader :options, :precision
 
         def render_e(source)
-          localized_notation_parts(source).join(options.exponent_separator.to_s)
+          coefficient, exponent = resolve_notation_parts(source,
+                                                         precision: precision)
+          build_notation(coefficient, :e, exponent)
         end
 
         def render_scientific(source)
-          localized_notation_parts(source).join(" #{options.times} 10^")
+          coefficient, exponent = resolve_notation_parts(source,
+                                                         precision: precision)
+          build_notation(coefficient, :scientific, exponent)
         end
 
         def render_engineering(source)
           parts = notation_parts(source)
-          parts = engineering_notation_parts(parts) unless source.decimal.zero?
-          parts[0] = localize_parts(source, parts[0], precision: engineering_precision(source))
-          parts.join(" #{options.times} 10^")
+          parts = engineering_coefficient_parts(parts) unless source.decimal.zero?
+          coefficient = localize_parts(source, parts[0],
+                                       precision: engineering_precision(source, parts[0]))
+          build_notation(coefficient, :engineering, parts[1])
+        end
+
+        def resolve_notation_parts(source, precision:)
+          parts = notation_parts(source)
+          coefficient = localize_parts(source, parts[0], precision: precision)
+          [coefficient, parts[1]]
+        end
+
+        def build_notation(coefficient, style, exponent)
+          FormattedNotation.new(
+            coefficient: coefficient,
+            notation_style: style,
+            exponent: exponent,
+            times_symbol: options.times,
+            exponent_separator: options.exponent_separator.to_s,
+            exponent_sign: options.exponent_sign,
+          )
         end
 
         def localize_parts(source, parts, precision:)
@@ -58,15 +79,11 @@ module Plurimath
           )
         end
 
-        def localized_notation_parts(source)
-          parts = notation_parts(source)
-          parts[0] = localize_parts(source, parts[0], precision: precision)
-          parts[1] = render_exponent(parts[1])
-          parts
-        end
-
         def notation_parts(source)
-          return [source.to_parts(base: options.base), 0] if source.decimal.zero?
+          if source.decimal.zero?
+            return [source.to_parts(base: options.base),
+                    0]
+          end
 
           parts = source.to_parts(base: Base::DEFAULT_BASE)
           digits, exponent = significant_digits_and_exponent(parts)
@@ -81,13 +98,15 @@ module Plurimath
           ]
         end
 
-        def engineering_notation_parts(parts)
+        def engineering_coefficient_parts(parts)
           coefficient, exponent = parts
           index = exponent % 3
-          exponent -= index
+          new_exponent = exponent - index
           digits = "#{coefficient.integer_digits}#{coefficient.fraction_digits}"
           integer_length = index + 1
-          integer_digits = digits[0...integer_length].to_s.ljust(integer_length, "0")
+          integer_digits = digits[0...integer_length].to_s.ljust(
+            integer_length, "0"
+          )
 
           [
             Parts.new(
@@ -96,14 +115,31 @@ module Plurimath
               integer_digits: integer_digits,
               fraction_digits: digits[integer_length..].to_s,
             ),
-            render_exponent(exponent),
+            new_exponent,
           ]
         end
 
-        def engineering_precision(source)
-          return precision if precision.positive?
+        # The inferred budget covers the source's significant digits; the
+        # engineering shift moves one to three of them into the integer part
+        # (per exponent mod 3), so the fraction budget must subtract the
+        # shifted integer width. Only a positive explicit precision is taken
+        # as a literal fraction width; precision: 0 falls through to inference.
+        def engineering_precision(source, coefficient)
+          return precision if options.explicit_precision? && precision.positive?
+          return source.notation_precision if source.decimal.zero?
+
+          integer_length = coefficient.integer_digits.length
+          budget = [options.significant, options.digit_count].max
+          unless budget.positive?
+            return [source.significant_digit_count - integer_length,
+                    0].max
+          end
 
-          [source.significant_digit_count - 1, 0].max
+          fraction_budget = [budget - integer_length, 0].max
+          # Leave one digit for Significant's rounding pass when the source
+          # carries more digits than the requested budget.
+          fraction_budget += 1 if source.significant_digit_count > budget
+          fraction_budget
         end
 
         def significant_digits_and_exponent(parts)
@@ -116,12 +152,6 @@ module Plurimath
             [digits[index..], parts.integer_digits.length - index - 1]
           end
         end
-
-        def render_exponent(exponent)
-          return "0" if exponent.zero?
-
-          exponent_sign_renderer.apply(exponent, exponent.abs.to_s)
-        end
       end
     end
   end

data/lib/plurimath/formatter/numbers/number_renderer.rb

@@ -11,42 +11,46 @@ module Plurimath
         def initialize(source, options)
           @source = source
           @options = options
-          @base_notation = BaseNotation.new(@options)
+          @base_notation = BaseNotation.from_options(@options)
           @integer_format = Integer.new(@options)
           @fraction_format = Fraction.new(@options)
           @significant_format = Significant.new(@options)
-          @parts_renderer = PartsRenderer.new(
-            integer_formatter: @integer_format,
-            fraction_formatter: @fraction_format,
-          )
-          @sign_renderer = SignRenderer.new(@options.number_sign)
         end
 
         def format(precision: nil)
           render_precision = precision || options.precision || source_precision
           parts = source.to_parts(
             base: options.base,
-            precision: render_precision,
+            precision: decimal_precision_for(render_precision),
           )
           format_parts(parts, precision: render_precision)
         end
 
         def format_parts(parts, precision:)
-          parts = parts.with_digits(
-            fraction_digits: parts.fraction_digits[0...precision.to_i].to_s,
-          )
+          decimal_precision = decimal_precision_for(precision)
+          unless decimal_precision.nil?
+            parts = parts.with_digits(
+              fraction_digits: parts.fraction_digits[0...decimal_precision.to_i].to_s,
+            )
+          end
           parts = renderable_parts(parts, precision: precision)
 
           parts = significant_format.apply_parts(parts) if significant_format.active?
-          result = parts_renderer.render(parts)
 
-          sign_renderer.apply(parts, base_notation.apply(result))
+          FormattedNumber.new(
+            sign: parts.sign,
+            integer_part: integer_format.format_groups(parts.integer_digits),
+            fraction_part: parts.fractional? ? fraction_format.format_groups(parts.fraction_digits) : "",
+            decimal_separator: fraction_format.decimal,
+            base_notation: base_notation,
+            number_sign: options.number_sign,
+          )
         end
 
         private
 
         attr_reader :base_notation, :fraction_format, :integer_format,
-                    :parts_renderer, :significant_format, :sign_renderer
+                    :significant_format
 
         def renderable_parts(parts, precision:)
           parts = parts.with_digits(
@@ -60,6 +64,15 @@ module Plurimath
 
           source.fraction_digits.length
         end
+
+        # Precision budgets target-base digits, so the decimal fraction must
+        # stay intact until Fraction#change_base generates them; truncating
+        # decimal digits first loses value (0.07 in hex became 0x0.0).
+        def decimal_precision_for(precision)
+          return precision if options.base == Base::DEFAULT_BASE
+
+          nil
+        end
       end
     end
   end

data/lib/plurimath/formatter/numbers/omml_renderer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Renders a Formatter result (FormattedNotation, FormattedNumber, or
+      # String) into an OMML element tree. Number delegates to this so the
+      # model does not carry format-specific XML construction.
+      module OmmlRenderer
+        module_function
+
+        def render(result)
+          case result
+          when FormattedNotation then render_notation(result)
+          when FormattedNumber
+            result.base_notation.semantic? ? render_semantic_base(result) : plain_element(result)
+          else
+            plain_element(result)
+          end
+        end
+
+        def render_notation(notation)
+          return plain_element(notation) if notation.notation_style == :e
+
+          sup_struct = Utility.ox_element("sSup", namespace: "m")
+          subpr = Utility.ox_element("sSupPr", namespace: "m")
+          subpr << Utility.pr_element("ctrl", true, namespace: "m")
+
+          coeff_run = text_run(notation.coefficient.to_s)
+          times_run = text_run(" #{notation.times_symbol} ")
+          base_run = text_run("10")
+          exp_run = text_run(notation.formatted_exponent)
+
+          e_el = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(e_el, [coeff_run, times_run, base_run])
+
+          sup_el = Utility.ox_element("sup", namespace: "m")
+          Utility.update_nodes(sup_el, [exp_run])
+
+          Utility.update_nodes(sup_struct, [subpr, e_el, sup_el])
+          sup_struct
+        end
+
+        def render_semantic_base(formatted)
+          sub_struct = Utility.ox_element("sSub", namespace: "m")
+          subpr = Utility.ox_element("sSubPr", namespace: "m")
+          subpr << Utility.pr_element("ctrl", true, namespace: "m")
+
+          digits_with_sign = "#{formatted.sign_text}#{formatted.digits_string}"
+          base_run = text_run(digits_with_sign)
+          sub_run = text_run(formatted.base_notation.base.to_s)
+
+          e_el = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(e_el, [base_run])
+
+          sub_el = Utility.ox_element("sub", namespace: "m")
+          Utility.update_nodes(sub_el, [sub_run])
+
+          Utility.update_nodes(sub_struct, [subpr, e_el, sub_el])
+          sub_struct
+        end
+
+        def plain_element(result)
+          Utility.ox_element("t", namespace: "m") << result.to_s
+        end
+
+        def text_run(text)
+          run = Utility.ox_element("r", namespace: "m")
+          run << (Utility.ox_element("t", namespace: "m") << text)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers/precision_resolver.rb

@@ -5,17 +5,30 @@ module Plurimath
     module Numbers
       # Chooses which precision source wins for one render call.
       class PrecisionResolver
-        def resolve(source, precision:, base:, significant:, notation_supported:)
+        def resolve(source, precision:, base:, significant:,
+notation_supported:, digit_count: 0)
           return precision if precision
 
-          significant_precision = significant_base_precision(source, base, significant)
+          significant_precision = significant_base_precision(source, base,
+                                                             significant)
           return significant_precision if significant_precision
 
           # Source owns input-derived digit lengths; this resolver only decides
           # which precision rule wins. Plain decimal rendering preserves
           # fractional scale, while notation precision controls coefficient
           # digits after the leading digit.
-          return source.notation_precision if notation_supported
+          if notation_supported
+            # A requested digit budget (significant or digit_count) widens the
+            # coefficient fraction beyond the source's own significant digits
+            # (one digit leads, so the fraction allowance is budget - 1).
+            budget = [significant, digit_count].max
+            if budget.positive?
+              return [budget - 1,
+                      source.notation_precision].max
+            end
+
+            return source.notation_precision
+          end
 
           source.decimal_precision
         end

data/lib/plurimath/formatter/numbers/sign_renderer.rb

@@ -20,7 +20,8 @@ module Plurimath
         def prefix(number)
           return "-" if number.negative?
 
-          "+" if positive_sign&.to_sym == :plus
+          # FormatOptions delivers a normalized Symbol (or nil) here.
+          "+" if positive_sign == :plus
         end
       end
     end

data/lib/plurimath/formatter/numbers/significant.rb

@@ -75,7 +75,8 @@ module Plurimath
 
           fraction = reversed[0...decimal_index]
           integer = reversed[(decimal_index + 1)..]
-          fraction, carry = digit_sequence.increment_reversed(fraction, overflow: EMPTY_STRING)
+          fraction, carry = digit_sequence.increment_reversed(fraction,
+                                                              overflow: EMPTY_STRING)
           return fraction + [CANONICAL_DECIMAL] + integer unless carry.positive?
 
           integer = increment_integer(integer)
@@ -83,7 +84,8 @@ module Plurimath
         end
 
         def increment_integer(reversed)
-          digits, carry = digit_sequence.increment_reversed(reversed, overflow: ZERO)
+          digits, carry = digit_sequence.increment_reversed(reversed,
+                                                            overflow: ZERO)
           digits << "1" if carry.positive?
           digits
         end

data/lib/plurimath/formatter/numbers/source.rb

@@ -13,10 +13,15 @@ module Plurimath
 
         DEFAULT_INTEGER = "0"
         EMPTY_STRING = ""
+        # Stricter than BigDecimal(), which tolerates underscores, surrounding
+        # junk after partial parses, and Infinity/NaN spellings.
+        NUMERIC_PATTERN = /\A[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?\z/
 
-        def initialize(value)
+        def initialize(value, base: Base::DEFAULT_BASE)
           @raw = value.to_s
-          @decimal = BigDecimal(raw)
+          @base = base || Base::DEFAULT_BASE
+          validate_numeric!(value)
+          @decimal = parse_decimal
           @sign = raw.start_with?("-") ? -1 : 1
 
           mantissa, @exponent_text = unsigned_value.split("e", 2)
@@ -33,9 +38,13 @@ module Plurimath
         end
 
         def notation_precision
-          precision = integer_digits.length + fraction_digits.length - 1
-          precision += 1 if sign.negative?
-          [precision, 0].max
+          # A zero coefficient keeps the source's stated fraction width.
+          return fraction_digits.length if decimal.zero?
+
+          # The coefficient's fraction width is its significant-digit count
+          # minus the single leading digit; the sign and leading zeros carry
+          # no precision.
+          [significant_digit_count - 1, 0].max
         end
 
         def significant_digit_count
@@ -71,6 +80,27 @@ module Plurimath
 
         private
 
+        # Converts the raw string to BigDecimal. For non-decimal bases with
+        # alphanumeric digits (e.g. "FF" in hex), uses #to_i(base) to convert.
+        # Pure-decimal inputs (e.g. "255") are parsed directly by BigDecimal.
+        def parse_decimal
+          return BigDecimal(raw) if decimal_input?
+
+          stripped = raw.sub(/\A[-+]/, "")
+          BigDecimal(stripped.to_i(@base))
+        end
+
+        def validate_numeric!(value)
+          valid_type = value.is_a?(Numeric) || value.is_a?(String)
+          return if valid_type && (non_decimal_base? || NUMERIC_PATTERN.match?(raw))
+
+          raise Plurimath::Errors::InvalidNumber, value
+        end
+
+        def non_decimal_base?
+          @base != Base::DEFAULT_BASE
+        end
+
         def decimal_parts_integer_length
           parts = to_parts
           return 0 if parts.integer_zero?
@@ -112,7 +142,17 @@ module Plurimath
         end
 
         def unsigned_value
-          raw.downcase.sub(/\A[-+]/, "")
+          return raw.downcase.sub(/\A[-+]/, "") if decimal_input?
+
+          @decimal.abs.to_s("F").downcase.sub(/\A[-+]/, "").delete_suffix(".0")
+        end
+
+        # Returns true when the raw value is a plain decimal string (digits,
+        # optional decimal point, optional exponent), meaning BigDecimal(raw)
+        # works directly.
+        def decimal_input?
+          stripped = raw.sub(/\A[-+]/, "")
+          stripped.match?(/\A[0-9.]+(?:e[+-]?[0-9]+)?\z/i)
         end
       end
     end

data/lib/plurimath/formatter/numbers/text_renderer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Renders a Formatter result (FormattedNotation, FormattedNumber, or
+      # String) into a plain-text format (LaTeX, AsciiMath, HTML, UnicodeMath).
+      # For semantic base notation, each format's template lives in
+      # BASE_TEMPLATES; adding a new text format is a one-line change there.
+      # When the caller supplies an explicit base_prefix/base_postfix, the
+      # literal prefix+postfix take precedence (no format-specific decoration).
+      module TextRenderer
+        # %<sign>s %<digits>s %<base>d — sign_text returns "" for positives
+        # without explicit :plus, so interpolation collapses cleanly.
+        BASE_TEMPLATES = {
+          asciimath: "%<sign>s%<digits>s_(%<base>d)",
+          unicodemath: "%<sign>s%<digits>s_(%<base>d)",
+          latex: "%<sign>s\\mathrm{%<digits>s}_{%<base>d}",
+          html: "%<sign>s%<digits>s<sub>%<base>d</sub>",
+        }.freeze
+
+        module_function
+
+        def render(result, format)
+          return result.to_s unless structured_number?(result)
+
+          if result.base_notation.literal?
+            result.to_s
+          else
+            render_semantic(result, format)
+          end
+        end
+
+        def structured_number?(result)
+          result.is_a?(FormattedNumber) && result.base_notation?
+        end
+        private_class_method :structured_number?
+
+        def render_semantic(result, format)
+          return result.to_s unless result.base_notation.semantic?
+
+          template = BASE_TEMPLATES.fetch(format)
+          format(template,
+                 sign: result.sign_text.to_s,
+                 digits: result.digits_string,
+                 base: result.base_notation.base)
+        end
+        private_class_method :render_semantic
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numbers.rb

@@ -4,20 +4,24 @@ module Plurimath
   module Formatter
     module Numbers
       autoload :Base, "#{__dir__}/numbers/base"
-      autoload :DigitSequence, "#{__dir__}/numbers/digit_sequence"
       autoload :BaseNotation, "#{__dir__}/numbers/base_notation"
+      autoload :DigitSequence, "#{__dir__}/numbers/digit_sequence"
       autoload :Fraction, "#{__dir__}/numbers/fraction"
       autoload :FormatOptions, "#{__dir__}/numbers/format_options"
+      autoload :FormattedNumber, "#{__dir__}/numbers/formatted_number"
+      autoload :FormattedNotation, "#{__dir__}/numbers/formatted_notation"
       autoload :Integer, "#{__dir__}/numbers/integer"
+      autoload :MathmlRenderer, "#{__dir__}/numbers/mathml_renderer"
       autoload :NumberRenderer, "#{__dir__}/numbers/number_renderer"
       autoload :NotationRenderer, "#{__dir__}/numbers/notation_renderer"
+      autoload :OmmlRenderer, "#{__dir__}/numbers/omml_renderer"
       autoload :Parts, "#{__dir__}/numbers/parts"
-      autoload :PartsRenderer, "#{__dir__}/numbers/parts_renderer"
       autoload :PrecisionResolver, "#{__dir__}/numbers/precision_resolver"
       autoload :SignRenderer, "#{__dir__}/numbers/sign_renderer"
       autoload :Significant, "#{__dir__}/numbers/significant"
       autoload :Source, "#{__dir__}/numbers/source"
       autoload :SymbolResolver, "#{__dir__}/numbers/symbol_resolver"
+      autoload :TextRenderer, "#{__dir__}/numbers/text_renderer"
     end
   end
 end

data/lib/plurimath/formatter/standard.rb

@@ -35,6 +35,12 @@ module Plurimath
       end
 
       def set_default_options(options)
+        unless options.nil? || options.is_a?(Hash)
+          raise Plurimath::ConfigurationError.new(
+            :invalid_formatter_option, option: :options, value: options, supported: "a Hash"
+          )
+        end
+
         options = options ? options.dup : {}
         apply_default_symbols(options)
         options

data/lib/plurimath/formatter/supported_locales.rb

@@ -118,7 +118,7 @@ module Plurimath
           locale_key = key_for(locale)
           return locale_key if locale.nil? || locale_key
 
-          raise UnsupportedLocale.new(locale, LOCALES.keys)
+          raise Plurimath::Errors::UnsupportedLocale.new(locale, LOCALES.keys)
         end
 
         def key_for(locale)

data/lib/plurimath/formatter.rb

@@ -3,8 +3,6 @@
 module Plurimath
   module Formatter
     autoload :SupportedLocales, "#{__dir__}/formatter/supported_locales"
-    autoload :UnsupportedBase, "#{__dir__}/errors/formatter/unsupported_base"
-    autoload :UnsupportedLocale, "#{__dir__}/errors/formatter/unsupported_locale"
     autoload :Numbers, "#{__dir__}/formatter/numbers"
     autoload :Standard, "#{__dir__}/formatter/standard"
   end

data/lib/plurimath/html/parse.rb

@@ -3,6 +3,8 @@
 module Plurimath
   class Html
     class Parse < Parslet::Parser
+      include Plurimath::BaseNumberPrefix::Parser
+
       rule(:space)   { match["\s"].repeat(1) }
       rule(:unary)   { array_to_expression(Constants::UNARY_CLASSES, :unary) }
       rule(:binary)  { str("lim").as(:binary) }
@@ -75,6 +77,9 @@ module Plurimath
       rule(:symbol_text_or_tag) do
         tag_parse |
           html_entity.as(:symbol) |
+          hex_number |
+          binary_number |
+          octal_number |
           (match["0-9"].repeat(1) >> decimal_marker >> match["0-9"].repeat(1)).as(:number) |
           match["0-9"].repeat(1).as(:number) |
           match["a-zA-Z"].as(:text) |