plurimath 0.10.2 → 0.10.3

data/lib/plurimath/cli.rb

@@ -4,7 +4,6 @@ require "thor"
 require_relative "../plurimath"
 
 module Plurimath
-
   class Cli < Thor
     desc "convert", "Convert between math formats"
 
@@ -30,7 +29,7 @@ module Plurimath
     option :math_rendering,
            aliases: "-m",
            force: :boolean,
-           default: 'false',
+           default: "false",
            desc: "Render converted equation as math zone display tree, Boolean only"
 
     option :display_style,
@@ -56,7 +55,7 @@ module Plurimath
       input_format   = options[:input_format]
       output_format  = options[:output_format]
       configure_xml_engine(input_format, output_format)
-      formula        = Plurimath::Math.parse(input_string, input_format)
+      formula = Plurimath::Math.parse(input_string, input_format)
       return puts formula.to_display(output_format.to_sym) if YAML.safe_load(options[:math_rendering])
 
       display_style  = options[:display_style]
@@ -68,11 +67,13 @@ module Plurimath
                     when "asciimath"
                       formula.to_asciimath
                     when "mathml"
-                      formula.to_mathml(display_style: style, split_on_linebreak: split)
+                      formula.to_mathml(display_style: style,
+                                        split_on_linebreak: split)
                     when "latex"
                       formula.to_latex
                     when "omml"
-                      formula.to_omml(display_style: style, split_on_linebreak: split)
+                      formula.to_omml(display_style: style,
+                                      split_on_linebreak: split)
                     else
                       warn_and_exit("Invalid output format: #{output_format}")
                     end

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

@@ -5,7 +5,9 @@ module Plurimath
     class UnsupportedBase < StandardError
       def initialize(base, supported_bases)
         @base = base
-        @supported = supported_bases.keys.map { |key| key.to_s.inspect }.join(", ")
+        @supported = supported_bases.keys.map do |key|
+          key.to_s.inspect
+        end.join(", ")
       end
 
       def to_s

data/lib/plurimath/formatter/number_formatter.rb

@@ -6,7 +6,7 @@ module Plurimath
       attr_reader :number, :data_reader
 
       DEFAULT_BASE = Numbers::Base::DEFAULT_BASE
-      HEX_ALPHABETS = "abcdef".freeze
+      HEX_ALPHABETS = "abcdef"
       STRING_SYMBOLS = {
         dot: ".",
         f: "F",
@@ -22,7 +22,10 @@ module Plurimath
         @number = number
         @data_reader = data_reader
         @base = data_reader[:base] || DEFAULT_BASE
-        raise UnsupportedBase.new(@base, DEFAULT_BASE_PREFIXES) unless DEFAULT_BASE_PREFIXES.key?(@base)
+        unless DEFAULT_BASE_PREFIXES.key?(@base)
+          raise UnsupportedBase.new(@base,
+                                    DEFAULT_BASE_PREFIXES)
+        end
 
         # Handle base_prefix: if explicitly provided (even as nil), use it; otherwise use default
         @base_prefix = if data_reader.key?(:base_prefix)
@@ -91,7 +94,7 @@ module Plurimath
         precision = options[:precision] || precision_from(number)
 
         abs = round_to(number, precision).abs
-        num = if precision == 0
+        num = if precision.zero?
                 abs.fix.to_s(STRING_SYMBOLS[:f])
               else
                 abs.round(precision).to_s(STRING_SYMBOLS[:f])

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

@@ -54,7 +54,7 @@ module Plurimath
           tokens = []
           until string.empty?
             tokens << string.slice(0, length)
-            string = string[tokens.last.size..-1]
+            string = string[tokens.last.size..]
           end
           tokens.compact.join(separator)
         end
@@ -67,7 +67,7 @@ module Plurimath
             # 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
+              if fraction[0] && DIGIT_VALUE[fraction[0]] >= threshold
                 # Round up the integer part
                 round_integer([], 1)
               end
@@ -126,7 +126,9 @@ module Plurimath
 
         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)
+          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),
@@ -175,7 +177,7 @@ module Plurimath
             digit = fraction.to_i
             alpha_digit = HEX_ALPHANUMERIC[digit]
             base_result << alpha_digit
-            fraction -= digit  # Remove integer part, keep only fractional part
+            fraction -= digit # Remove integer part, keep only fractional part
           end
 
           base_result.join

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

@@ -14,6 +14,7 @@ module Plurimath
 
         def apply(string, int_format, frac_format)
           return string if significant.zero?
+
           # Check if string contains any non-zero digit (works across all bases 2-16)
           chars = string.chars
           return string if skip_significant_processing?(chars)
@@ -149,6 +150,7 @@ module Plurimath
           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
           char_count

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -3,7 +3,8 @@
 module Plurimath
   module Formatter
     class NumericFormatter
-      attr_accessor :locale, :localize_number, :localizer_symbols, :twitter_cldr_reader
+      attr_accessor :locale, :localize_number, :localizer_symbols,
+                    :twitter_cldr_reader
 
       LOCALIZE_NUMBER_REGEX = %r{(?<group>[^#])?(?<groupdigits>#+0)(?<decimal>.)(?<fractdigits>#+)(?<fractgroup>[^#])?}
       SUPPORTED_NOTATIONS = %i[e scientific engineering].freeze
@@ -18,7 +19,10 @@ module Plurimath
       def localized_number(number_string, locale:, precision:, format:)
         options_instance_variables(number_string, format, precision)
         @twitter_cldr_reader.merge!(format)
-        return send("#{@notation}_format", number_string) if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+        if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+          return send("#{@notation}_format",
+                      number_string)
+        end
 
         localize_number(number_string)
       end
@@ -35,12 +39,12 @@ module Plurimath
       def parse_localize_number
         @localize_number or return {}
         m = LOCALIZE_NUMBER_REGEX.match(@localize_number) or return {}
-        ret = {
+        {
           decimal: m[:decimal],
           group_digits: m[:groupdigits].size,
           fraction_group_digits: m[:fractdigits].size,
           group: m[:group] == " " ? "\u00A0" : (m[:group] || ""),
-          fraction_group: m[:fractgroup] == " " ? "\u00A0" : (m[:fractgroup]  || "")
+          fraction_group: m[:fractgroup] == " " ? "\u00A0" : (m[:fractgroup] || ""),
         }.compact
       end
 
@@ -49,7 +53,7 @@ module Plurimath
           BigDecimal(num),
           @twitter_cldr_reader,
         ).format(
-          precision: @precision
+          precision: @precision,
         )
       end
 
@@ -62,7 +66,7 @@ module Plurimath
       end
 
       def engineering_format(num_str)
-        @precision = num_str.length - 1 unless @precision > 0
+        @precision = num_str.length - 1 unless @precision.positive?
 
         chars = notation_chars(num_str)
         update_string_index(chars, chars.last.to_i % 3)
@@ -85,8 +89,9 @@ module Plurimath
         notation_array[1] = update_exponent_value(notation_array[1])
         number_str = notation_array[0]
         number_str = number_str.gsub(/0\.(\d)/, '\1.')
-        number_str = number_str.sub('.', '') if number_str.start_with?(".")
-        notation_array[0] = number_str.end_with?(".") ? number_str[0..-2] : number_str
+        number_str = number_str.sub(".", "") if number_str.start_with?(".")
+        notation_array[0] =
+          number_str.end_with?(".") ? number_str[0..-2] : number_str
         notation_array
       end
 
@@ -101,15 +106,71 @@ module Plurimath
         @e = format[:e]&.to_sym || :e
         @times = format[:times]&.to_sym || "\u{d7}"
         @notation = format[:notation]&.to_sym || nil
-        @precision = update_precision(string, precision)
+        @precision = update_precision(string, precision, format)
         @exponent_sign = format[:exponent_sign]&.to_sym || nil
       end
 
-      def update_precision(num, precision)
+      def update_precision(num, precision, format)
         return precision if precision
-        return num.sub(/\./, "").size - 1 if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
 
-        /\./.match?(num) ? num.sub(/^.*\./, "").size : 0
+        significant_precision = significant_base_precision(num, format)
+        return significant_precision if significant_precision
+
+        if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+          return num.sub(".",
+                         "").size - 1
+        end
+
+        num.include?(".") ? num.sub(/^.*\./, "").size : 0
+      end
+
+      # When precision is omitted, infer the target-base fractional digits
+      # needed to satisfy :significant. Cap the count to the source significant
+      # digits so base conversion does not invent precision for values like 0.1.
+      # Add one extra digit when the source has more significant digits so
+      # Significant can still perform the final rounding pass.
+      def significant_base_precision(num, format)
+        base = format[:base] || Formatter::NumberFormatter::DEFAULT_BASE
+        return unless target_base?(base)
+
+        significant = format[:significant].to_i
+        return if significant.zero?
+
+        return 0 unless source_fractional?(num)
+
+        source_significant = source_significant_digits(num)
+        effective_significant = [significant, source_significant].min
+        target_precision = [
+          effective_significant - target_base_integer_length(num, base),
+          0,
+        ].max
+
+        target_precision += 1 if source_significant > effective_significant
+        target_precision
+      end
+
+      def target_base?(base)
+        Formatter::NumberFormatter::DEFAULT_BASE_PREFIXES.key?(base) &&
+          base != Formatter::NumberFormatter::DEFAULT_BASE
+      end
+
+      def source_fractional?(num)
+        mantissa, exponent = num.to_s.downcase.split("e", 2)
+        fraction_length = mantissa.split(".", 2)[1].to_s.length
+
+        fraction_length > exponent.to_i
+      end
+
+      def source_significant_digits(num)
+        mantissa = num.to_s.downcase.split("e", 2).first
+        mantissa.sub(/\A[-+]/, "").delete(".").sub(/\A0+/, "").length
+      end
+
+      def target_base_integer_length(num, base)
+        integer = BigDecimal(num).abs.to_i
+        return 0 if integer.zero?
+
+        integer.to_s(base).length
       end
 
       def update_string_index(chars, index)
@@ -118,7 +179,8 @@ module Plurimath
         chars.first.delete!(".")
         chars.first.insert(index + 1, ".") unless chars.first[index + 2].nil?
         exponent = chars[-1]
-        chars[-1] = "#{"+" if exponent.to_s.start_with?("+")}#{exponent.to_i - index}"
+        chars[-1] =
+          "#{'+' if exponent.to_s.start_with?('+')}#{exponent.to_i - index}"
       end
     end
   end

data/lib/plurimath/formatter/standard.rb

@@ -21,7 +21,8 @@ module Plurimath
         e: "e",
       }.freeze
 
-      def initialize(locale: "en", string_format: nil, options: {}, precision: nil)
+      def initialize(locale: "en", string_format: nil, options: {},
+precision: nil)
         super(
           locale,
           localize_number: string_format,
@@ -34,14 +35,38 @@ module Plurimath
         default_options = self.class::DEFAULT_OPTIONS
         self.precision ||= default_options[:precision]
         options ||= default_options
-        options[:fraction_group_digits] = default_options[:fraction_group_digits] unless options.key?(:fraction_group_digits)
-        options[:fraction_group] = default_options[:fraction_group] unless options.key?(:fraction_group)
-        options[:exponent_sign] = default_options[:exponent_sign] unless options.key?(:exponent_sign)
-        options[:group_digits] = default_options[:group_digits] unless options.key?(:group_digits)
-        options[:number_sign] = default_options[:number_sign] unless options.key?(:number_sign)
-        options[:significant] = default_options[:significant] unless options.key?(:significant)
-        options[:notation] = default_options[:notation] unless options.key?(:notation)
-        options[:decimal] = default_options[:decimal] unless options.key?(:decimal)
+        unless options.key?(:fraction_group_digits)
+          options[:fraction_group_digits] =
+            default_options[:fraction_group_digits]
+        end
+        unless options.key?(:fraction_group)
+          options[:fraction_group] =
+            default_options[:fraction_group]
+        end
+        unless options.key?(:exponent_sign)
+          options[:exponent_sign] =
+            default_options[:exponent_sign]
+        end
+        unless options.key?(:group_digits)
+          options[:group_digits] =
+            default_options[:group_digits]
+        end
+        unless options.key?(:number_sign)
+          options[:number_sign] =
+            default_options[:number_sign]
+        end
+        unless options.key?(:significant)
+          options[:significant] =
+            default_options[:significant]
+        end
+        unless options.key?(:notation)
+          options[:notation] =
+            default_options[:notation]
+        end
+        unless options.key?(:decimal)
+          options[:decimal] =
+            default_options[:decimal]
+        end
         options[:group] = default_options[:group] unless options.key?(:group)
         options[:times] = default_options[:times] unless options.key?(:times)
         options[:e] = default_options[:e] unless options.key?(:e)

data/lib/plurimath/formatter/supported_locales.rb

@@ -100,7 +100,7 @@ module Plurimath
         xh: { decimal: ".", group: " " },
         zh: { decimal: ".", group: "," },
         zu: { decimal: ".", group: "," },
-      }
+      }.freeze
     end
   end
 end

data/lib/plurimath/html/transform.rb

@@ -5,17 +5,19 @@ module Plurimath
     class Transform < Parslet::Transform
       rule(text: simple(:text))      { Math::Function::Text.new(text) }
       rule(unary: simple(:unary))    { Utility.get_class(unary).new }
-      rule(symbol: simple(:symbol))  { Utility.symbols_class(symbol, lang: :html) }
+      rule(symbol: simple(:symbol))  do
+        Utility.symbols_class(symbol, lang: :html)
+      end
       rule(number: simple(:number))  { Math::Number.new(number) }
       rule(expression: simple(:exp)) { exp }
-      
+
       rule(expression: sequence(:exp))    { exp }
       rule(sequence: simple(:sequence))   { sequence }
       rule(tr_value: simple(:tr_value))   { Math::Function::Tr.new([tr_value]) }
       rule(td_value: simple(:td_value))   { Math::Function::Td.new([td_value]) }
       rule(sequence: sequence(:sequence)) { sequence }
       rule(td_value: sequence(:td_value)) { Math::Function::Td.new(td_value) }
-      
+
       rule(parse_parenthesis: simple(:parse_paren)) { parse_paren }
       rule(unary_function: simple(:unary_function)) { unary_function }
 
@@ -82,7 +84,7 @@ module Plurimath
       rule(unary_function: simple(:unary_function),
            sequence: sequence(:sequence)) do
         Math::Formula.new(
-          ([unary_function] + sequence),
+          [unary_function] + sequence,
         )
       end
 

data/lib/plurimath/latex/constants.rb

@@ -211,7 +211,7 @@ module Plurimath
         end
 
         def parenthesis
-          @@parens ||= {"\\(" => "\\)", "\\[" => "\\]", "\\{" => "\\}"}
+          @@parens ||= { "\\(" => "\\)", "\\[" => "\\]", "\\{" => "\\}" }
           rejected_paren(:close?).each do |paren, klass|
             @@parens[paren] = klass.new.closing::INPUT[:latex].flatten
           end
@@ -221,7 +221,7 @@ module Plurimath
         private
 
         def symbols_hash
-          latex_symbols.map { |sym, klass| [sym, :symbols] }.compact.to_h
+          latex_symbols.filter_map { |sym, _klass| [sym, :symbols] }.to_h
         end
 
         def latex_symbols

data/lib/plurimath/latex/parse.rb

@@ -7,9 +7,13 @@ module Plurimath
       rule(:power)         { str("^") }
       rule(:slash)         { str("\\") }
       rule(:under_over)    { slash >> underover_classes }
-      rule(:array_args)    { (str("{") >> expression.as(:args) >> str("}")) }
-      rule(:array_begin)   { (str("\\begin{") >> str("array").as(:environment) >> str("}")) }
-      rule(:optional_args) { (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe }
+      rule(:array_args)    { str("{") >> expression.as(:args) >> str("}") }
+      rule(:array_begin)   do
+        str("\\begin{") >> str("array").as(:environment) >> str("}")
+      end
+      rule(:optional_args) do
+        (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe
+      end
 
       rule(:color) do
         (str("{") >> (str("}").absent? >> any).repeat.as(:symbol) >> str("}")) |
@@ -94,7 +98,7 @@ module Plurimath
 
       rule(:symbol_text_or_integer) do
         str('"').as(:symbol) |
-          rparen.absent? >> symbol_class_commands |
+          (rparen.absent? >> symbol_class_commands) |
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
           (match["0-9"].repeat(0) >> str(".").maybe >> match["0-9"].repeat(1)).as(:number) |
@@ -111,7 +115,7 @@ module Plurimath
       end
 
       rule(:parsing_text_values) do
-        (str("{") >> parsing_text_values >> str("}")) >> parsing_text_values |
+        ((str("{") >> parsing_text_values >> str("}")) >> parsing_text_values) |
           (str("{") >> parsing_text_values >> str("}")) |
           (match("[^}]") >> parsing_text_values) |
           match("[^}]").repeat
@@ -149,12 +153,11 @@ module Plurimath
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
           intermediate_exp |
-          intermediate_exp.as(:intermediate_exp) >> rparen.as(:symbol)
+          (intermediate_exp.as(:intermediate_exp) >> rparen.as(:symbol))
       end
 
       rule(:left_right) do
-        (
-          str("\\left").as(:left) >> (left_parens | str(".").maybe) >>
+        str("\\left").as(:left) >> (left_parens | str(".").maybe) >>
           (
             (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
             expression.as(:expression).maybe
@@ -162,7 +165,6 @@ module Plurimath
           (
             str("\\right").as(:right).maybe >> (right_parens | str(".").maybe)
           )
-        )
       end
 
       rule(:over_class) do
@@ -197,7 +199,10 @@ module Plurimath
 
       def hash_to_expression(hash)
         @@expression ||= hash.reduce do |expression, (key, value)|
-          expression = dynamic_rules(expression.first, expression.last) if expression.is_a?(Array)
+          if expression.is_a?(Array)
+            expression = dynamic_rules(expression.first,
+                                       expression.last)
+          end
           expression | dynamic_rules(key, value)
         end
       end
@@ -206,26 +211,32 @@ module Plurimath
         first_value = str(expr.to_s)
         case name
         when :operant
-          (first_value.as(:operant) | (slashed_value(first_value, :symbols)))
+          (first_value.as(:operant) | slashed_value(first_value, :symbols))
         when :symbols
           slashed_value(first_value, :symbols)
         when :unary
           unary_rules(first_value)
         when :fonts
-          (slashed_value(first_value, :fonts) >> (binary_functions | intermediate_exp).as(:intermediate_exp))
+          (slashed_value(first_value,
+                         :fonts) >> (binary_functions | intermediate_exp).as(:intermediate_exp))
         when :power_base
-          (slashed_value(first_value, :binary) >> dynamic_power_base).as(:power_base) |
-            (slashed_value(first_value, :binary))
+          (slashed_value(first_value,
+                         :binary) >> dynamic_power_base).as(:power_base) |
+            slashed_value(first_value, :binary)
         when :underover
           (slashed_value(first_value, :underover) >> dynamic_power_base) |
-            (slashed_value(first_value, :underover) >> intermediate_exp.maybe.as(:first_value) >> dynamic_power_base) |
-            (slashed_value(first_value, :underover))
+            (slashed_value(first_value,
+                           :underover) >> intermediate_exp.maybe.as(:first_value) >> dynamic_power_base) |
+            slashed_value(first_value, :underover)
         when :binary
-          (slashed_value(first_value, :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
+          (slashed_value(first_value,
+                         :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
         when :text
-          (slashed_value(first_value, :text) >> (str("{") >> parsing_text_values.as(:first_value) >> str("}")))
+          (slashed_value(first_value,
+                         :text) >> (str("{") >> parsing_text_values.as(:first_value) >> str("}")))
         when :ternary
-          (slashed_value(first_value, :ternary_functions) >> dynamic_power_base >> sequence.as(:third_value).maybe).as(:ternary_class) |
+          (slashed_value(first_value,
+                         :ternary_functions) >> dynamic_power_base >> sequence.as(:third_value).maybe).as(:ternary_class) |
             slashed_value(first_value, :ternary)
         end
       end
@@ -236,8 +247,10 @@ module Plurimath
 
       def unary_rules(first_value)
         (slashed_value(first_value, :unary_functions) >> dynamic_power_base) |
-          (slashed_value(first_value, :unary) >> left_right.as(:first_value)).as(:unary_functions) |
-          (slashed_value(first_value, :unary) >> intermediate_exp.as(:first_value)).as(:unary_functions) |
+          (slashed_value(first_value,
+                         :unary) >> left_right.as(:first_value)).as(:unary_functions) |
+          (slashed_value(first_value,
+                         :unary) >> intermediate_exp.as(:first_value)).as(:unary_functions) |
           slashed_value(first_value, :unary)
       end
 

data/lib/plurimath/latex/parser.rb

@@ -5,7 +5,7 @@ module Plurimath
     class Parser
       attr_accessor :text
 
-      TEXT_REGEX = %r(\\(?:mbox|text)\{[^\}]+\})
+      TEXT_REGEX = %r(\\(?:mbox|text)\{[^}]+\})
 
       def initialize(text)
         @enti = ::HTMLEntities.new
@@ -26,17 +26,17 @@ module Plurimath
         text_functions = text.scan(TEXT_REGEX)
         text = @enti.encode(@enti.decode(text), :hexadecimal)
         text = gsub_space_and_unicodes(text)
-        text.gsub(TEXT_REGEX) { |str| text_functions.shift }
+        text.gsub(TEXT_REGEX) { |_str| text_functions.shift }
       end
 
       def gsub_space_and_unicodes(text)
         text
           .gsub(/((?<!\\) )|\n+/, "")
-          .gsub(/\\\\ /, "\\\\\\\\")
-          .gsub(/&#x26;/, "&")
-          .gsub(/&#x22;/, "\"")
+          .gsub("\\\\ ", "\\\\\\\\")
+          .gsub("&#x26;", "&")
+          .gsub("&#x22;", "\"")
           .gsub(/(?<!\\\\)\\&#xa;/, "\\ ")
-          .gsub(/&#xa;/, "")
+          .gsub("&#xa;", "")
       end
     end
   end