plurimath 0.9.11 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ecaec3071c4b2925d95eceffec830c054c840c7813db4f0b8f4e6e95c366ced
-  data.tar.gz: 19adb5616581e744f45805329324b950dcad692c670fa07153579ff71f319d05
+  metadata.gz: 3e78c38692b0343fbe7666f309339f0e94180803b8aa81e48c71897d37eab606
+  data.tar.gz: 44c7c9ae6c2fb5d9b09d869c09c91775172f77b9bf27dee0aeb511f5bb272046
 SHA512:
-  metadata.gz: a4d1ee78250433329ab39e542804c8199afcf9afecb43027c76611c9619fc6f4eb72d2e49ff0b93c801d53f2986ee97b926217c0fe99c57898992aa900f12079
-  data.tar.gz: 020112a942828e93440ebdc3c95af0a720c8766411f4edf19cca7ec1f39423c67b8808a6cb95ef01e99429dc6f7d06d322f63829b3b2f7a832d2e308fd1aedd9
+  metadata.gz: 4d79d19001092a56d19ae94705c3777460fd24cd57ebca84b1a6ee1d9b68ed473e0cf3799d45c58ba6af6f3aa0e56dc8b8160559bc43c70404885adb024a2232
+  data.tar.gz: c256d08993caa5a78caded66b7aaa65c8c7a52f413bb14dacfafbe29f2984fa604516942a8b28b5684486f34eb99ca3da8f03dc5f11513a41381484e0a507d7d

data/.github/workflows/release.yml

@@ -15,6 +15,9 @@ on:
 
 jobs:
   release:
+    permissions:
+      contents: write
+      id-token: write
     uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
     with:
       next_version: ${{ github.event.inputs.next_version }}

data/README.adoc

@@ -129,7 +129,7 @@ plurimath convert -i "equation" -f omml -t mathml -d true
 ====
 [source,bash]
 ----
-plurimath convert -e <file_path> -t unicodemath
+plurimath convert -p <file_path> -f asciimath -t unicodemath
 ----
 ====
 
@@ -524,14 +524,25 @@ Symbol to use for the decimal point. Accepts a character.
 ====
 
 `digit_count`:: (`Numeric` value)
-Total number of digits to render, with the value truncated.
-Accepts an integer value.
+Total number of digits to render (integer + fractional), with the value truncated
+or rounded as necessary. Accepts an integer value.
++
+When `digit_count` is less than or equal to the integer length, the fractional
+part is omitted entirely, and the integer is rounded based on whether the
+fractional value is >= 0.5 (or >= base/2 for non-decimal bases).
 +
 .Specifying a total of 6 digits in rendering the number
 [example]
 ====
 "32232.232" => "32232.2"
 ====
++
+.When digit_count is smaller than the integer length
+[example]
+====
+"99999.999" with `digit_count: 3` => "100,000" (fractional part omitted, integer rounded up)
+"12345.123" with `digit_count: 3` => "12,345" (fractional part omitted, no rounding)
+====
 
 
 `group`:: (`String` value)
@@ -555,6 +566,116 @@ Accepts an integer value. (default is 3 in most locales.)
 "32232.232" => "3 22 32.232"
 ====
 
+`base`:: (`Numeric` value)
+Sets the numeric base (radix) used to render both the integer and fractional parts of the number.
+Supported values are 2 (binary), 8 (octal), 10 (decimal, default) and 16 (hexadecimal).
+Passing any other value for `base` raises `Plurimath::Formatter::UnsupportedBase`.
++
+.Rendering numbers in different bases
+[example]
+====
+"10"    with `base: 2, group_digits: 2, group: ","`  => "0b10,10"
+"9"     with `base: 8`  => "0o11"
+"255"   with `base: 16` => "0xff"
+"10.75" with `base: 2, group_digits: 2, group: ","`  => "0b10,10.11" (integer and fractional parts converted, with grouping)
+====
+
+`base_prefix`:: (`String` or `nil` value)
+Overrides the default base prefix for non‑decimal bases.
+When omitted, standard prefixes are used (`0b` for base 2, `0o` for base 8, `0x` for base 16).
+`nil` or an empty string can be used to omit the prefix.
++
+.Custom base prefixes
+[example]
+====
+"255" with `base: 16, base_prefix: "16#"` => "16#ff"
+"255" with `base: 16, base_prefix: nil`   => "ff"
+"255" with `base: 16, base_prefix: ""`   => "ff"
+====
+
+`base_postfix`:: (`String` value)
+If present, a postfix is appended to the converted number instead of using any base prefix.
+This is applied after digit grouping.
+`nil` or an empty string can be used to omit the postfix.
++
+.Using postfix notation
+[example]
+====
+"255" with `base: 16, base_postfix: "_16"` => "ff_16"
+"255" with `base: 16, base_postfix: nil` => "ff"
+"255" with `base: 16, base_postfix: ""` => "ff"
+====
+
+`hex_capital`:: (`Boolean` value)
+When `true` and `base: 16`, all characters in the range `a`-`f` in the converted output
+are rendered using uppercase letters. This includes both hexadecimal digits and any
+separators (such as `decimal`, `group`, `fraction_group`) that happen to be letters
+in the `a`-`f` range. The `base_prefix` and `base_postfix` values are never modified.
+It has no effect for other bases.
++
+.Uppercase hexadecimal output
+[example]
+====
+"48879" with `base: 16, hex_capital: true` => "0xBE,EF"
+====
++
+WARNING: If you use separator characters in the range `a`-`f` (such as `decimal: "d"` or `fraction_group: "f"`), those separators will also be uppercased when `hex_capital: true`. Choose separators outside this range (e.g., `".", ",", " ", "_"`) if you need them to remain unchanged.
++
+.Separator uppercasing behavior
+[example]
+====
+"48879" with `base: 16, hex_capital: true, group: "g"` => "0xBEgEF" (g remains lowercase)
+
+"48879" with `base: 16, hex_capital: true, group: "f"` => "0xBEFEF" (f separator becomes F)
+====
+
+NOTE: When `base` is not 10, both the integer and fractional parts are converted to the specified base.
+The decimal separator is rendered as configured by the `decimal` option.
++
+NOTE: The fractional-part conversion treats the digits after the decimal point as a fractional value (for example, `"10.75"` is interpreted
+as decimal `0.75` for the fractional part) and converts that real value to the requested base, honoring the configured precision.
+
+===== Base conversion with other formatting options
+
+Base conversion works seamlessly with other formatting options such as `precision`, `digit_count`,
+`fraction_group`, `fraction_group_digits`, and `significant`.
+
+.Base conversion with precision
+[example]
+====
+Controls the maximum number of fractional digits in the converted base (pads with zeros when needed and truncates repeating expansions to the configured precision):
++
+"10.75" with `base: 2, precision: 4` => "0b10,10.1100" (fractional part padded to 4 digits in base 2)
+"0.5"   with `base: 16, precision: 6` => "0x0.800000" (fractional part converted to base 16 and padded to 6 digits)
+====
+
+.Base conversion with fraction grouping
+[example]
+====
+Groups fractional digits in the converted base:
++
+"10.75" with `base: 2, fraction_group_digits: 1, fraction_group: " ", group_digits: 10` => "0b1010.1 1"
+====
+
+.Base conversion with digit_count
+[example]
+====
+Limits total digits when using base conversion:
++
+"14236.39239" with `base: 10, digit_count: 6, group_digits: 3` => "14,236.4"
+"10.75"       with `base: 2, digit_count: 7, group_digits: 10` => "0b1010.110"
+"255.9"       with `base: 16, digit_count: 2, group_digits: 10` => "0x100" (fractional part omitted, integer rounded)
+====
+
+.Base conversion with significant digits
+[example]
+====
+Applies significant digit rounding with base conversion:
++
+"1234.56" with `base: 10, significant: 4` => "1,235"
+"1999"    with `base: 10, significant: 2` => "2,000"
+====
+
 `fraction_group`:: (`String` value)
 Delimiter to use between groups of fractional digits specified in
 `fraction_group_digits`. Accepts a character.
@@ -607,7 +728,7 @@ selected to be divisible by three to match the common metric prefixes.
 ====
 
 `e`:: (`String` value)
-Symbol to use for exponents in E notation (default value `E`). (used in the
+Symbol to use for exponents in E notation (default value `e`). (used in the
 mode: `e` only).
 +
 .Using the lowercase 'e' symbol as the exponent symbol
@@ -743,9 +864,8 @@ formatter.localized_number(
 
 Where,
 
-`<number>`:: (mandatory) The number to be formatted. Value should be a Numeric,
-i.e. Integer, Float, or BigDecimal. If not provided, an `ArgumentError` will be
-raised.
+`<number>`:: (mandatory) The number to be formatted, as a `String` containing the
+decimal representation of the value (for example, `"1234.56789"`).
 
 `locale: <locale-symbol>`:: (optional) The locale to be used for number formatting.
 Value is a symbol.
@@ -1117,7 +1237,7 @@ locales are listed in the link:/blog/2024-07-09-number-formatter[number formatte
 `options`:: (default: empty) a hash of options (`localizer_symbols`). The options
 are listed in the link:/blog/2024-07-09-number-formatter[number formatter blog post].
 
-`format_string`:: (default: `nil`, disabled) a string value (localize_number)
+`string_format`:: (default: `nil`, disabled) a string value (`localize_number`)
 
 `precision`:: (default: `nil`, disabled) an integer value.
 
@@ -1136,7 +1256,7 @@ are listed in the link:/blog/2024-07-09-number-formatter[number formatter blog p
 }
 
 > formatter = Plurimath::Formatter::Standard.new(locale: :hy, options: options, precision: 2)
-# format_string: <string value> if provided
+# string_format: <string value> if provided
 
 > Plurimath::Math.parse('2121221.3434', :latex).to_latex(formatter: formatter)
 # => '2,12,12,21;34'
@@ -1160,7 +1280,7 @@ The custom formatter is to be subclassed from `Plurimath::Formatter::Standard`.
 [source,ruby]
 ----
 class MyCustomFormatter < Plurimath::Formatter::Standard <1>
-  def initialize(locale:, precision:, options:, format_string:) <2>
+  def initialize(locale:, precision:, options:, string_format:) <2>
     super
   end
 end
@@ -1175,7 +1295,7 @@ The default options of the custom formatter are set using the
 [source,ruby]
 ----
 class MyCustomFormatter < Plurimath::Formatter::Standard
-  def initialize(locale:, precision:, options:, format_string:)
+  def initialize(locale:, precision:, options:, string_format:)
     super
   end
 

data/lib/plurimath/asciimath.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "math"
 module Plurimath
   class Asciimath
     attr_accessor :text

data/lib/plurimath/cli.rb

@@ -77,7 +77,7 @@ module Plurimath
     no_commands do
       def warn_and_exit(message)
         warn(message)
-        exit 1
+        abort
       end
     end
   end

data/lib/plurimath/errors/formatter/unsupported_base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    class UnsupportedBase < StandardError
+      def initialize(base, supported_bases)
+        @base = base
+        @supported = supported_bases.keys.map { |key| key.to_s.inspect }.join(", ")
+      end
+
+      def to_s
+        <<~MESSAGE
+          [plurimath] Unsupported base `#{@base}` for number formatting.
+          [plurimath] The formatter `:base` option must be one of: #{@supported}.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/plurimath/errors/invalid_type_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class InvalidTypeError < TypeError
+      def initialize(type = nil)
+        super(type ? formula_message(type) : parse_message)
+      end
+
+      def parse_message
+        "`type` must be one of: `#{Math::VALID_TYPES.keys.join('`, `')}`"
+      end
+
+      def formula_message(type)
+        "Invalid type provided: #{type}. Must be one of #{Formula::MATH_ZONE_TYPES.join(', ')}."
+      end
+    end
+  end
+end

data/lib/plurimath/errors/parse_error.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class ParseError < StandardError
+      def initialize(text, type)
+        @text = text
+        @type = type.to_sym
+        super(@type == :invalid_unitsml ? unitsml_message : parsing_message)
+      end
+
+      def parsing_message
+        <<~MESSAGE
+          [plurimath] Error: Failed to parse the following formula with type `#{@type}`.
+          [plurimath] Please first manually validate the formula.
+          #{generic_part}
+          ---- FORMULA BEGIN ----
+          #{@text}
+          ---- FORMULA END ----
+        MESSAGE
+      end
+
+      def unitsml_message
+        <<~MESSAGE
+          [plurimath] Invalid formula `#{@text}`.
+          [plurimath] The use of a variable as an exponent is not valid.
+          #{generic_part}
+        MESSAGE
+      end
+
+      def generic_part
+        <<~MESSAGE.rstrip
+          [plurimath] If this is a bug, please report the formula at our issue tracker at:
+          [plurimath] https://github.com/plurimath/plurimath/issues
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/plurimath/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "errors/parse_error"
+require_relative "errors/invalid_type_error"
+require_relative "errors/formatter/unsupported_base"

data/lib/plurimath/formatter/number_formatter.rb

@@ -3,17 +3,33 @@
 module Plurimath
   module Formatter
     class NumberFormatter
-      attr_reader :number, :data_reader, :prefix
+      attr_reader :number, :data_reader
 
+      DEFAULT_BASE = Numbers::Base::DEFAULT_BASE
+      HEX_ALPHABETS = "abcdef".freeze
       STRING_SYMBOLS = {
-        dot: ".".freeze,
-        f: "F".freeze,
+        dot: ".",
+        f: "F",
+      }.freeze
+      DEFAULT_BASE_PREFIXES = {
+        2 => "0b",
+        8 => "0o",
+        10 => "",
+        16 => "0x",
       }.freeze
 
       def initialize(number, data_reader = {})
         @number = number
         @data_reader = data_reader
-        @prefix = "-" if number.negative?
+        @base = data_reader[:base] || DEFAULT_BASE
+        raise UnsupportedBase.new(@base, DEFAULT_BASE_PREFIXES) unless DEFAULT_BASE_PREFIXES.key?(@base)
+
+        # Handle base_prefix: if explicitly provided (even as nil), use it; otherwise use default
+        @base_prefix = if data_reader.key?(:base_prefix)
+                         data_reader[:base_prefix].to_s
+                       else
+                         DEFAULT_BASE_PREFIXES[@base]
+                       end
       end
 
       def format(precision: nil)
@@ -22,16 +38,37 @@ module Plurimath
         # FIX FOR:
         #   NotImplementedError: String#<< not supported. Mutable String methods are not supported in Opal.
         result = []
-        result << integer_format.apply(int, data_reader)
-        result << fraction_format.apply(frac, data_reader, int) if frac
+        result << integer_format.apply(int)
+        result << fraction_format.apply(frac, result, integer_format) # use formatted int for correct fraction formatting
         result = result.join
         result = signif_format.apply(result, integer_format, fraction_format)
-        result = "+#{result}" if number.positive? && data_reader[:number_sign].to_s == "plus"
-        "#{prefix}#{result}"
+        result = result.tr(HEX_ALPHABETS, HEX_ALPHABETS.upcase) if upcase_hex?
+        result = pre_post_fixed(result) unless base_default?
+        "#{prefix_symbol}#{result}"
       end
 
       private
 
+      def upcase_hex?
+        @base == 16 && data_reader[:hex_capital]
+      end
+
+      def prefix_symbol
+        if number.negative?
+          "-"
+        elsif data_reader[:number_sign]&.to_sym == :plus
+          "+"
+        end
+      end
+
+      def pre_post_fixed(result)
+        if data_reader.key?(:base_postfix)
+          "#{result}#{data_reader[:base_postfix]}"
+        else
+          "#{@base_prefix}#{result}"
+        end
+      end
+
       def partition_tokens(number)
         int, fraction = parse_number(number)
         [
@@ -53,10 +90,11 @@ module Plurimath
       def parse_number(number, options = data_reader)
         precision = options[:precision] || precision_from(number)
 
+        abs = round_to(number, precision).abs
         num = if precision == 0
-                round_to(number, precision).abs.fix.to_s(STRING_SYMBOLS[:f])
+                abs.fix.to_s(STRING_SYMBOLS[:f])
               else
-                round_to(number, precision).abs.round(precision).to_s(STRING_SYMBOLS[:f])
+                abs.round(precision).to_s(STRING_SYMBOLS[:f])
               end
         num.split(STRING_SYMBOLS[:dot])
       end
@@ -65,6 +103,10 @@ module Plurimath
         factor = BigDecimal(10).power(precision)
         (number * factor).fix / factor
       end
+
+      def base_default?
+        @base == DEFAULT_BASE
+      end
     end
   end
 end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      class Base
+        HEX_ALPHANUMERIC = %w[0 1 2 3 4 5 6 7 8 9 a b c d e f].freeze
+        DEFAULT_BASE = 10
+        DIGIT_VALUE = HEX_ALPHANUMERIC.each_with_index.to_h
+
+        attr_accessor :base, :symbols
+
+        def initialize(symbols = {})
+          @symbols = symbols
+          @base = symbols[:base] || DEFAULT_BASE
+        end
+
+        protected
+
+        def threshold
+          @threshold ||= base.div(2)
+        end
+
+        def base_default?
+          base == DEFAULT_BASE
+        end
+
+        def next_mapping_char(char)
+          current_idx = DIGIT_VALUE[char]
+          return nil unless current_idx
+
+          HEX_ALPHANUMERIC[current_idx + 1]
+        end
+      end
+    end
+  end
+end

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

@@ -3,69 +3,84 @@
 module Plurimath
   module Formatter
     module Numbers
-      class Fraction
+      class Fraction < Base
         attr_reader :decimal, :precision, :separator, :group
 
+        DEFAULT_PRECISION = 3
+        DEFAULT_STRINGS = { empty: "", zero: "0", dot: ".", f: "F" }.freeze
+
         def initialize(symbols = {})
-          @precision = 3
-          @decimal = symbols[:decimal] || '.'
-          @separator = symbols[:fraction_group].to_s
-          @group = symbols[:fraction_group_digits]
-          @digit_count = symbols[:digit_count] || nil
+          super
+          @group       = symbols[:fraction_group_digits]
+          @decimal     = symbols.fetch(:decimal, DEFAULT_STRINGS[:dot])
+          @int_group   = symbols[:group]
+          @separator   = symbols[:fraction_group].to_s
+          @precision   = symbols.fetch(:precision, DEFAULT_PRECISION)
+          @digit_count = symbols[:digit_count].to_i
         end
 
-        def apply(fraction, options = {}, int = "")
-          precision = options[:precision] || @precision
-          return "" unless precision > 0
+        def apply(fraction, result, integer_formatter)
+          precision = symbols[:precision] || @precision
+          @result = result
+          @integer_formatter = integer_formatter
+          return DEFAULT_STRINGS[:empty] unless precision.positive?
+
+          fraction = change_base(fraction) if !base_default? && fraction.match?(/[1-9]/)
 
-          number = if @digit_count
-                     digit_count_format(int, fraction)
+          number = if @digit_count.positive?
+                     digit_count_format(fraction)
                    else
                      format(fraction, precision)
                    end
-
-          formatted_number = change_format(number) if number
-          formatted_number ? decimal + formatted_number : ""
+          formatted_number = format_groups(number) if number && !number.empty?
+          formatted_number ? decimal + formatted_number : DEFAULT_STRINGS[:empty]
         end
 
         def format(number, precision)
-          number + "0" * (precision - number.length)
+          return number if precision <= number.length
+
+          number + (DEFAULT_STRINGS[:zero] * (precision - number.length))
         end
 
-        def format_groups(string)
-          change_format(string)
+        def format_groups(string, length = group)
+          length = string.length if group.to_i.zero?
+
+          change_format(string, length)
         end
 
         protected
 
-        def change_format(string)
+        def change_format(string, length)
           tokens = []
-          tokens << string&.slice!(0, (group || string.length)) until string&.empty?
+          until string.empty?
+            tokens << string.slice(0, length)
+            string = string[tokens.last.size..-1]
+          end
           tokens.compact.join(separator)
         end
 
-        def digit_count_format(int, fraction)
-          integer = int + "." + fraction
-          int_length = integer.length - 1 # integer length; excluding the decimal point
-          @digit_count ||= int_length
+        def digit_count_format(fraction)
+          integer = raw_integer + DEFAULT_STRINGS[:dot] + fraction
+          int_length = integer.length.pred # integer length; excluding the decimal point
           if int_length > @digit_count
-            number_string = BigDecimal(integer).round(@digit_count - int.length)
-            numeric_digits(number_string) if @digit_count > int.length
+            # When digit_count is less than or equal to the integer length,
+            # omit the fractional part entirely and handle rounding in the integer
+            if @digit_count <= raw_integer.length
+              # Check if we need to round the integer up based on the fractional part
+              if fraction.chars.first && DIGIT_VALUE[fraction.chars.first] >= threshold
+                # Round up the integer part
+                round_integer([], 1)
+              end
+              return DEFAULT_STRINGS[:empty]
+            end
+            round_base_string(fraction)
           elsif int_length < @digit_count
-            fraction + ("0" * (update_digit_count(fraction) - int_length))
+            fraction + (DEFAULT_STRINGS[:zero] * (update_digit_count(fraction) - int_length))
           else
             fraction
           end
         end
 
-        def numeric_digits(num_str)
-          float = num_str.to_s("F")
-          return float.split(".").last if float.length == @digit_count + 1
-          return unless @digit_count + 1 > float.length
-
-          float.split(".")[0] + ("0" * (@digit_count - float.length + 1))
-        end
-
         def update_digit_count(number)
           return @digit_count unless zeros_count_in(number) == @precision
 
@@ -73,10 +88,106 @@ module Plurimath
         end
 
         def zeros_count_in(number)
-          return unless number.split('').all? { |digit| digit == "0" }
+          return unless number.chars.all?(DEFAULT_STRINGS[:zero])
 
           number.length
         end
+
+        def round_base_string(fraction)
+          # Extract the digits we need, plus one extra digit for rounding decision
+          digits = fraction[0..frac_digit_count].chars
+          discard_char = digits.pop
+          return DEFAULT_STRINGS[:empty] unless discard_char
+          # If the discarded digit is below the rounding threshold (< base/2), truncate
+          return digits.join if DIGIT_VALUE[discard_char] < threshold
+
+          # Perform carry propagation for rounding up
+          carry = 1
+          rounded_reversed = []
+          digits.reverse_each do |digit|
+            next rounded_reversed << digit unless carry.positive?
+
+            # If current digit is at max value for this base (e.g., 'f' for base 16),
+            # set it to '0' and continue carrying
+            rounded_reversed << if DIGIT_VALUE[digit] == base.pred
+                                  DEFAULT_STRINGS[:zero]
+                                else
+                                  # Otherwise, increment this digit and stop carrying
+                                  carry = 0
+                                  next_mapping_char(digit)
+                                end
+          end
+
+          # If we still have a carry after processing all fractional digits,
+          # we need to round up the integer part
+          round_integer(rounded_reversed, carry) if carry.positive?
+          rounded_reversed.reverse.join unless rounded_reversed.empty?
+        end
+
+        def round_integer(fraction_digits_reversed, carry = 1)
+          # Propagate carry into the integer part, updating the formatted result
+          incremented, carry = increment_integer_digits(raw_integer.chars.reverse, carry)
+          new_integer = [incremented]
+          if carry.positive?
+            # If carry propagates through all integer digits (e.g., 9+1=10 in base 10),
+            # we need to prepend '1' and remove one fractional digit to maintain digit_count
+            fraction_digits_reversed.pop
+            new_integer.insert(0, "1")
+          end
+          # Update the result array with the new integer value
+          @result[0] = @integer_formatter.format_groups(new_integer.join)
+        end
+
+        def increment_integer_digits(digits, carry)
+          # Skip over separator characters while propagating carry through integer digits
+          str_chars = [decimal, @int_group]
+          digits.each_with_index do |digit, index|
+            next if str_chars.include?(digit)
+
+            if DIGIT_VALUE[digit] == base.pred
+              # Digit is at max value (e.g., 'f' for base 16), set to '0' and continue carry
+              digits[index] = DEFAULT_STRINGS[:zero]
+            else
+              # Increment this digit and stop carrying
+              digits[index] = next_mapping_char(digit)
+              break carry = 0
+            end
+          end
+
+          [digits.reverse.join, carry]
+        end
+
+        def change_base(number)
+          # Convert fractional part from base 10 to target base using rational arithmetic
+          # to avoid floating-point rounding errors.
+          # Algorithm: repeatedly multiply fraction by base, extract integer part as next digit
+          # Represent the fractional part exactly as a rational number to avoid
+          # binary floating-point rounding errors when converting bases.
+          # Note: The input `number` is always in decimal (base 10) format,
+          # so we use 10 as the denominator base regardless of the target base.
+          fraction = Rational(number.to_i, 10**number.length)
+
+          base_result = []
+          digits = @precision || number.length
+
+          digits.times do
+            fraction *= base
+            digit = fraction.to_i
+            alpha_digit = HEX_ALPHANUMERIC[digit]
+            base_result << alpha_digit
+            fraction -= digit  # Remove integer part, keep only fractional part
+          end
+
+          base_result.join
+        end
+
+        def raw_integer
+          @result[0].delete(@int_group.to_s)
+        end
+
+        def frac_digit_count
+          @digit_count - raw_integer.length
+        end
       end
     end
   end

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

@@ -3,28 +3,26 @@
 module Plurimath
   module Formatter
     module Numbers
-      class Integer
-        attr_reader :format, :separator, :groups
+      class Integer < Base
+        attr_reader :separator, :groups
+
+        DEFAULT_SEPARATOR = ","
 
         def initialize(symbols = {})
-          @groups    = Array(symbols[:group_digits] || 3)
-          @separator = symbols[:group] || ','
+          super
+          @groups    = symbols[:group_digits] || 3
+          @separator = symbols[:group] || DEFAULT_SEPARATOR
         end
 
-        def apply(number, options = {})
-          format_groups(number)
+        def apply(number)
+          format_groups(number_to_base(number))
         end
 
         def format_groups(string)
-          return string if groups.empty?
-
           tokens = []
 
-          tokens << chop_group(string, groups.first)
-          string = string[0...-tokens.first.size]
-
           until string.empty?
-            tokens << chop_group(string, groups.last)
+            tokens << chop_group(string, groups)
             string = string[0...-tokens.last.size]
           end
 
@@ -34,6 +32,12 @@ module Plurimath
         def chop_group(string, size)
           string.slice([string.size - size, 0].max, size)
         end
+
+        def number_to_base(number)
+          return number if base_default?
+
+          number.to_i.to_s(base)
+        end
       end
     end
   end

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

@@ -3,21 +3,20 @@
 module Plurimath
   module Formatter
     module Numbers
-      class Significant
-        attr_accessor :symbols, :decimal, :significant
+      class Significant < Base
+        attr_accessor :decimal, :significant
 
         def initialize(symbols)
-          @symbols = symbols
+          super
           @decimal = symbols[:decimal]
           @significant = symbols[:significant].to_i
         end
 
         def apply(string, int_format, frac_format)
           return string if significant.zero?
-          return string unless string.match?(/[1-9]/)
-          chars = string.split("")
-
-          return string if count_chars(chars, true) == significant
+          # Check if string contains any non-zero digit (works across all bases 2-16)
+          chars = string.chars
+          return string if skip_significant_processing?(chars)
 
           string = signify(chars)
           integer, fraction = string.split(decimal)
@@ -29,77 +28,73 @@ module Plurimath
         protected
 
         def signify(chars)
-          sig_num   = false
-          frac_part = false
-          new_chars = []
-          sig_count = significant
-          chars.each_with_index do |char, ind|
-            frac_part ||= char == decimal
-            sig_num ||= char.match?(/[1-9]/)
-            break if sig_count.zero?
-
-            new_chars << char
-            next unless sig_num
-            next unless char.match?(/[0-9]/)
-
-            sig_count -= 1
-          end
-
-          if sig_count > 0
+          new_chars, frac_part, sig_count = process_chars(chars)
+          if sig_count.positive?
             new_chars << decimal unless frac_part
           else
             remain_chars = count_chars(chars, frac_part) - significant
-            if remain_chars > 0
+            if remain_chars.positive?
               round_str(chars, new_chars, frac_part)
-              remain_chars = 0 if frac_part && remain_chars == 1
+              # After rounding, recalculate remain_chars only for fractional numbers
+              # where we need to adjust padding based on actual significant digits
+              if frac_part
+                # Check if decimal point still exists after rounding
+                has_decimal = new_chars.include?(decimal)
+                if has_decimal
+                  # Fractional part still exists, recalculate padding
+                  actual_sig = count_significant_digits(new_chars)
+                  remain_chars = [significant - actual_sig, 0].max
+                else
+                  # Rounding eliminated the fractional part from a number that originally had one
+                  # Don't add trailing zeros in this case
+                  remain_chars = 0
+                  frac_part = false
+                end
+              end
+              # For integer-only numbers (frac_part = false from the start),
+              # remain_chars stays as calculated initially
             end
-            new_chars << ("0" * remain_chars) unless frac_part && sig_char_count(new_chars)
+            new_chars << ("0" * remain_chars) unless frac_part && sig_char_count?(new_chars)
           end
           new_chars.join
         end
 
         def round_str(chars, array, frac_part)
           arr_len = array.length
-          char_ind = chars[arr_len]&.match?(/[0-9]/) ? arr_len : arr_len + 1
-          return unless chars[char_ind]&.match?(/[5-9]/)
+          char_ind = DIGIT_VALUE.key?(chars[arr_len]) ? arr_len : arr_len.next
+          return unless char_ind < chars.length && DIGIT_VALUE[chars[char_ind]] >= threshold
 
           frac_part = false if chars[arr_len] == decimal
-          prev_ten  = false
+          carry = false
           array.reverse!.each_with_index do |char, ind|
             if char == decimal
               array[ind] = ""
               frac_part  = false
               next
             end
-            next unless char.match?(/[0-9]/)
+            next unless DIGIT_VALUE.key?(char)
 
-            if char == "9"
-              prev_ten   = true
+            if DIGIT_VALUE[char] == base.pred
+              carry = true
               array[ind] = frac_part ? "" : "0"
-              next
+            else
+              array[ind] = next_mapping_char(char)
+              carry = false
+              break
             end
-            char.next!
-            prev_ten = false
-            break
           end
-          array << "1" if prev_ten
+          array << "1" if carry
           array.reverse!
         end
 
         def count_chars(chars, fraction)
-          counting = 0
+          char_count = 0
           chars.each do |char|
             break if char == decimal && !fraction
 
-            counting += 1 if char.match?(/\d/)
+            char_count += 1 if DIGIT_VALUE.key?(char)
           end
-          counting
-        end
-
-        def change_format(string, separator, group)
-          tokens = []
-          tokens << string&.slice!(0, group) until string&.empty?
-          tokens.compact.join(separator)
+          char_count
         end
 
         def format_groups(format, string)
@@ -110,16 +105,53 @@ module Plurimath
           string.split(format.separator).join
         end
 
-        def sig_char_count(chars)
+        def sig_char_count?(chars)
           start_counting = false
-          counting = 0
+          char_count = 0
           chars.each do |char|
-            start_counting = true if char.match(/[1-9]/)
+            start_counting = true if DIGIT_VALUE[char]&.positive?
             next unless start_counting
 
-            counting += 1 if char.match?(/\d/)
+            char_count += 1 if DIGIT_VALUE.key?(char)
+          end
+          char_count == significant
+        end
+
+        def process_chars(chars, sig_num: false, frac_part: false)
+          sig_count = significant
+          new_chars = []
+          chars.each do |char|
+            frac_part ||= char == decimal
+            sig_num ||= DIGIT_VALUE[char]&.positive?
+            break if sig_count.zero?
+
+            new_chars << char
+            next unless sig_num
+            next unless DIGIT_VALUE.key?(char)
+
+            sig_count -= 1
+          end
+
+          [new_chars, frac_part, sig_count]
+        end
+
+        def skip_significant_processing?(chars)
+          # Skip if no significant digits exist, or if we already have the exact count needed
+          chars.none? { |c| DIGIT_VALUE.key?(c) && DIGIT_VALUE[c].positive? } ||
+            count_chars(chars, true) == significant
+        end
+
+        def count_significant_digits(chars)
+          # Count actual significant digits in the character array
+          # Leading zeros don't count as significant
+          start_counting = false
+          char_count = 0
+          chars.each do |char|
+            start_counting = true if DIGIT_VALUE[char]&.positive?
+            next unless start_counting
+            char_count += 1 if DIGIT_VALUE.key?(char)
           end
-          counting == significant
+          char_count
         end
       end
     end

data/lib/plurimath/formatter.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "errors/formatter/unsupported_base"
 require_relative "formatter/numeric_formatter"
 require_relative "formatter/supported_locales"
+require_relative "formatter/numbers/base"
 require_relative "formatter/numbers/integer"
 require_relative "formatter/numbers/fraction"
 require_relative "formatter/numbers/significant"

data/lib/plurimath/math/core.rb

@@ -352,6 +352,7 @@ module Plurimath
           :@using_default,
           :@displaystyle,
           :@__encoding,
+          :@__register,
           :@__ordered,
           :@unitsml,
           :@__mixed,

data/lib/plurimath/math/formula.rb

@@ -419,11 +419,18 @@ module Plurimath
       def mstyle_value=(value)
         return if value.nil? || value.empty?
 
+        replacing_order = value.length > 1 && value.any?(String)
         update(
           filter_values(
             replace_order_with_value(
               @value,
-              Array(filter_values(value, array_to_instance: true)),
+              Array(
+                filter_values(
+                  value,
+                  array_to_instance: true,
+                  replacing_order: replacing_order,
+                ),
+              ),
               "mstyle"
             )
           )
@@ -624,7 +631,7 @@ module Plurimath
       end
 
       def parse_error!(type)
-        Math.parse_error!(input_string, type)
+        raise ParseError.new(input_string, type)
       end
 
       def omml_br_tag
@@ -986,9 +993,7 @@ module Plurimath
       # Dd derivative nodes end
 
       def type_error!(type)
-        raise Math::InvalidTypeError.new(
-          "Invalid type provided: #{type}. Must be one of #{MATH_ZONE_TYPES.join(', ')}.",
-        )
+        raise Math::InvalidTypeError.new(type)
       end
     end
   end

data/lib/plurimath/math/function/font_style.rb

@@ -51,15 +51,78 @@ module Plurimath
         end
 
         def font_styles(display_style, sty: "p", scr: nil, options:)
+          children = flatten_omml_nodes(
+            Array(parameter_one&.font_style_t_tag(display_style, options: options)),
+          )
+          return [empty_font_style_r_tag(sty, scr)] if children.empty?
+
+          if children.all? { |node| node.is_a?(String) || t_tag_node?(node) }
+            r_tag = empty_font_style_r_tag(sty, scr)
+            Utility.update_nodes(r_tag, children)
+            return [r_tag]
+          end
+
+          children.flat_map do |node|
+            if r_tag_node?(node)
+              inject_font_style_rpr(node, sty, scr)
+              [node]
+            elsif t_tag_node?(node)
+              r_tag = empty_font_style_r_tag(sty, scr)
+              r_tag << node
+              [r_tag]
+            else
+              inject_font_style_recursive(node, sty, scr)
+              [node]
+            end
+          end
+        end
+
+        def flatten_omml_nodes(nodes)
+          nodes.each_with_object([]) do |node, result|
+            if node.is_a?(Array)
+              result.concat(flatten_omml_nodes(node))
+            elsif !node.nil?
+              result << node
+            end
+          end
+        end
+
+        def t_tag_node?(node)
+          node.respond_to?(:name) && node.name == "m:t"
+        end
+
+        def r_tag_node?(node)
+          node.respond_to?(:name) && node.name == "m:r"
+        end
+
+        def empty_font_style_r_tag(sty, scr)
           r_tag = Utility.ox_element("r", namespace: "m")
           rpr_tag = Utility.ox_element("rPr", namespace: "m")
           rpr_tag << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
           rpr_tag << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
-          Utility.update_nodes(
-            (r_tag << rpr_tag),
-            Array(parameter_one&.font_style_t_tag(display_style, options: options)),
-          )
-          [r_tag]
+          r_tag << rpr_tag
+          r_tag
+        end
+
+        def inject_font_style_rpr(r_node, sty, scr)
+          return if r_node.nodes.any? { |n| n.respond_to?(:name) && n.name == "m:rPr" }
+
+          rpr_tag = Utility.ox_element("rPr", namespace: "m")
+          rpr_tag << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
+          rpr_tag << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
+          r_node.insert_in_nodes(0, rpr_tag)
+        end
+
+        def inject_font_style_recursive(node, sty, scr)
+          return unless node.respond_to?(:nodes)
+
+          node.nodes.each do |child|
+            if r_tag_node?(child)
+              inject_font_style_rpr(child, sty, scr)
+            elsif child.respond_to?(:nodes)
+              inject_font_style_recursive(child, sty, scr)
+            end
+          end
         end
 
         def to_asciimath_math_zone(spacing, last = false, _, options:)

data/lib/plurimath/math.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "errors"
 require_relative "asciimath"
 require_relative "omml"
 require_relative "unicode_math"
@@ -27,9 +28,6 @@ require "yaml"
 
 module Plurimath
   module Math
-    class ParseError < StandardError; end
-    class InvalidTypeError < TypeError; end
-
     VALID_TYPES = {
       omml: Omml,
       html: Html,
@@ -41,15 +39,18 @@ module Plurimath
     }.freeze
 
     def parse(text, type)
-      type_error! unless valid_type?(type)
+      raise InvalidTypeError.new unless valid_type?(type)
 
       begin
         klass = klass_from_type(type)
         formula = klass.new(text).to_formula
         formula.input_string = text
         formula
+      rescue ParseError
+        # Re-raise ParseError from lower layers unchanged to preserve specialized error types
+        raise
       rescue => ee
-        parse_error!(text, type.to_sym)
+        raise ParseError.new(text, type), cause: nil
       end
     end
 
@@ -59,30 +60,11 @@ module Plurimath
       VALID_TYPES[type_string_or_sym.to_sym]
     end
 
-    def parse_error!(text, type)
-      message = <<~MESSAGE
-        [plurimath] Error: Failed to parse the following formula with type `#{type}`.
-        [plurimath] Please first manually validate the formula.
-        [plurimath] If this is a bug, please report the formula at our issue tracker at:
-        [plurimath] https://github.com/plurimath/plurimath/issues
-        ---- FORMULA BEGIN ----
-        #{text}
-        ---- FORMULA END ----
-      MESSAGE
-      raise ParseError.new(message), cause: nil
-    end
-
-    def type_error!
-      raise InvalidTypeError.new(
-        "`type` must be one of: `#{VALID_TYPES.keys.join('`, `')}`",
-      )
-    end
-
     def valid_type?(type)
       (type.is_a?(::Symbol) || type.is_a?(String)) &&
         VALID_TYPES.key?(type.to_sym)
     end
 
-    module_function :parse, :klass_from_type, :parse_error!, :type_error!, :valid_type?
+    module_function :parse, :klass_from_type, :valid_type?
   end
 end

data/lib/plurimath/mathml.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "math"
-
 module Plurimath
   class Mathml
     attr_accessor :text

data/lib/plurimath/unitsml.rb

@@ -5,24 +5,17 @@ module Plurimath
   class Unitsml
     attr_accessor :text
 
-    VALID_UNITSML = %r{\^(([^\s][^*\/,"]*?[a-z]+)|(\([^-\d]+\)|[^\(\d-]+))}
+    # Match ^ followed by content containing letters (indicating variables as exponents, which are invalid)
+    # Simplified regex to avoid catastrophic backtracking (ReDoS vulnerability)
+    VALID_UNITSML = /\^\(?-?\d*[a-z]/i
 
     def initialize(text)
       @text = text
-      raise Math::ParseError.new(error_message) if text.match?(VALID_UNITSML)
+      raise Math::ParseError.new(text, :invalid_unitsml) if text.match?(VALID_UNITSML)
     end
 
     def to_formula
       Math::Function::Unitsml.new(text)
     end
-
-    def error_message
-      <<~MESSAGE
-       [plurimath] Invalid formula `#{@text}`.
-       [plurimath] The use of a variable as an exponent is not valid.
-       [plurimath] If this is a bug, please report the formula at our issue tracker at:
-       [plurimath] https://github.com/plurimath/plurimath/issues
-      MESSAGE
-    end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.9.11"
+  VERSION = "0.10.0"
 end

data/plurimath.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mml'
   spec.add_dependency 'thor'
   spec.add_dependency 'parslet'
+  spec.add_dependency 'ostruct'
   spec.add_dependency 'unitsml'
   spec.add_dependency 'bigdecimal'
   spec.add_dependency 'lutaml-model'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.9.11
+  version: 0.10.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-05 00:00:00.000000000 Z
+date: 2026-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: unitsml
   requirement: !ruby/object:Gem::Requirement
@@ -149,8 +163,13 @@ files:
 - lib/plurimath/asciimath/parser.rb
 - lib/plurimath/asciimath/transform.rb
 - lib/plurimath/cli.rb
+- lib/plurimath/errors.rb
+- lib/plurimath/errors/formatter/unsupported_base.rb
+- lib/plurimath/errors/invalid_type_error.rb
+- lib/plurimath/errors/parse_error.rb
 - lib/plurimath/formatter.rb
 - lib/plurimath/formatter/number_formatter.rb
+- lib/plurimath/formatter/numbers/base.rb
 - lib/plurimath/formatter/numbers/fraction.rb
 - lib/plurimath/formatter/numbers/integer.rb
 - lib/plurimath/formatter/numbers/significant.rb