plurimath 0.11.1 → 0.11.3

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Structured result of notation formatting (e, scientific, engineering).
+      # Carries the coefficient as a FormattedNumber, the exponent as an
+      # integer, and notation style metadata so output renderers (MathML,
+      # LaTeX, etc.) can produce structured representations instead of flat
+      # strings.
+      class FormattedNotation
+        STYLES = %i[e scientific engineering].freeze
+
+        attr_reader :coefficient, :notation_style, :exponent,
+                    :times_symbol, :exponent_separator, :exponent_sign
+
+        def initialize(
+          coefficient:,
+          notation_style:,
+          exponent:,
+          times_symbol: "×",
+          exponent_separator: "e",
+          exponent_sign: nil
+        )
+          @coefficient = coefficient
+          @notation_style = notation_style
+          @exponent = exponent
+          @times_symbol = times_symbol
+          @exponent_separator = exponent_separator
+          @exponent_sign = exponent_sign
+        end
+
+        def to_s
+          case notation_style
+          when :e
+            "#{coefficient}#{exponent_separator}#{formatted_exponent}"
+          when :scientific, :engineering
+            "#{coefficient} #{times_symbol} 10^#{formatted_exponent}"
+          end
+        end
+
+        def to_str
+          to_s
+        end
+
+        def base_notation?
+          coefficient.base_notation?
+        end
+
+        # The exponent rendered as a string, applying sign conventions.
+        # Public so that output renderers can access it directly.
+        def formatted_exponent
+          return "0" if exponent.zero?
+
+          sign_prefix = exponent_sign == :plus ? "+" : nil
+          abs_exp = exponent.abs.to_s
+          exponent.negative? ? "-#{abs_exp}" : "#{sign_prefix}#{abs_exp}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      # Structured result of number formatting. Carries sign, digit parts,
+      # decimal separator, and base notation as separate semantic elements
+      # so output renderers (MathML, LaTeX, etc.) can produce structured
+      # representations instead of flat strings.
+      class FormattedNumber
+        attr_reader :sign, :integer_part, :fraction_part,
+                    :decimal_separator, :base_notation, :number_sign
+
+        def initialize(
+          sign:,
+          integer_part:,
+          fraction_part:,
+          decimal_separator:,
+          base_notation:,
+          number_sign: nil
+        )
+          @sign = sign
+          @integer_part = integer_part
+          @fraction_part = fraction_part
+          @decimal_separator = decimal_separator
+          @base_notation = base_notation
+          @number_sign = number_sign
+        end
+
+        def negative?
+          sign == -1
+        end
+
+        def fractional?
+          !fraction_part.empty?
+        end
+
+        def base_notation?
+          !base_notation.default?
+        end
+
+        # The sign as a rendering prefix: "-" for negative, "+" when
+        # number_sign is :plus, nil otherwise. Output renderers use this
+        # to produce format-specific sign elements.
+        def sign_text
+          if negative?
+            "-"
+          elsif number_sign == :plus
+            "+"
+          end
+        end
+
+        def to_s
+          digits = formatted_digits
+          digits = base_notation.wrap(digits) unless base_notation.default?
+          "#{sign_text}#{digits}"
+        end
+
+        def to_str
+          to_s
+        end
+
+        # Digits with decimal separator and optional hex capitalization,
+        # but without sign, prefix, or postfix. Used by structured renderers
+        # that handle sign and base notation as separate elements.
+        def digits_string
+          formatted_digits
+        end
+
+        private
+
+        def formatted_digits
+          digits = assembled_digits
+          base_notation.upcase_hex? ? upcase_hex(digits) : digits
+        end
+
+        def assembled_digits
+          fractional? ? "#{integer_part}#{decimal_separator}#{fraction_part}" : integer_part
+        end
+
+        def upcase_hex(string)
+          string.tr(Base::HEX_DIGITS, Base::HEX_DIGITS.upcase)
+        end
+      end
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module Plurimath
         end
 
         # Keep fraction preparation on structured parts; localized rendering and
-        # grouping happen later at the PartsRenderer boundary.
+        # grouping happen later at the FormattedNumber boundary.
         def apply_parts(parts, precision: self.precision)
           precision = precision.to_i
           return parts.with_digits(fraction_digits: DEFAULT_STRINGS[:empty]) unless precision.positive?

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,25 +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[0]),
+          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,
           )
-          parts.join(" #{options.times} 10^")
         end
 
         def localize_parts(source, parts, precision:)
@@ -62,13 +79,6 @@ 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)
           if source.decimal.zero?
             return [source.to_parts(base: options.base),
@@ -88,10 +98,10 @@ 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(
@@ -105,7 +115,7 @@ module Plurimath
               integer_digits: integer_digits,
               fraction_digits: digits[integer_length..].to_s,
             ),
-            render_exponent(exponent),
+            new_exponent,
           ]
         end
 
@@ -115,10 +125,7 @@ module Plurimath
         # 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)
-          # precision: 0 is intentionally not literal here; it infers.
           return precision if options.explicit_precision? && precision.positive?
-          # Zero sources carry their stated fraction width; an explicit
-          # precision: 0 still infers (consistent with non-zero engineering).
           return source.notation_precision if source.decimal.zero?
 
           integer_length = coefficient.integer_digits.length
@@ -145,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,15 +11,10 @@ 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)
@@ -41,15 +36,21 @@ module Plurimath
           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(

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/source.rb

@@ -17,10 +17,11 @@ module Plurimath
         # 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
+          @base = base || Base::DEFAULT_BASE
           validate_numeric!(value)
-          @decimal = BigDecimal(raw)
+          @decimal = parse_decimal
           @sign = raw.start_with?("-") ? -1 : 1
 
           mantissa, @exponent_text = unsigned_value.split("e", 2)
@@ -79,13 +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 && NUMERIC_PATTERN.match?(raw)
+          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?
@@ -127,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/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) |

data/lib/plurimath/html/transform.rb

@@ -3,6 +3,8 @@
 module Plurimath
   class Html
     class Transform < Parslet::Transform
+      include Plurimath::BaseNumberPrefix::Transform
+
       rule(text: simple(:text))      { Math::Function::Text.new(text) }
       rule(unary: simple(:unary))    { Utility.get_class(unary).new }
       rule(symbol: simple(:symbol)) { TransformUtility.symbol(symbol) }

data/lib/plurimath/latex/parse.rb

@@ -3,6 +3,8 @@
 module Plurimath
   class Latex
     class Parse < Parslet::Parser
+      include Plurimath::BaseNumberPrefix::Parser
+
       rule(:base)          { str("_") }
       rule(:power)         { str("^") }
       rule(:slash)         { str("\\") }
@@ -101,6 +103,9 @@ module Plurimath
           (rparen.absent? >> symbol_class_commands) |
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
+          hex_number |
+          binary_number |
+          octal_number |
           (match["0-9"].repeat(0) >> decimal_marker.maybe >> match["0-9"].repeat(1)).as(:number) |
           match["0-9"].repeat(1).as(:number) |
           (str("\\\\").as("\\\\") >> match(/\s/).repeat) |

data/lib/plurimath/latex/transform.rb

@@ -3,6 +3,8 @@
 module Plurimath
   class Latex
     class Transform < Parslet::Transform
+      include Plurimath::BaseNumberPrefix::Transform
+
       rule(base: simple(:base))       { base }
       rule(over: simple(:over))       { over }
       rule(number: simple(:num))      { Math::Number.new(Utility.html_entity_to_unicode(num.to_s)) }