plurimath 0.11.0 → 0.11.3

data/lib/plurimath/math/number.rb

@@ -3,48 +3,59 @@
 module Plurimath
   module Math
     class Number < Core
-      attr_accessor :value, :mini_sub_sized, :mini_sup_sized
+      attr_accessor :value, :mini_sub_sized, :mini_sup_sized, :base
 
-      def initialize(value = nil, mini_sub_sized: false, mini_sup_sized: false)
+      def initialize(value = nil, mini_sub_sized: false, mini_sup_sized: false,
+                     base: nil)
         @value = value.is_a?(::Parslet::Slice) ? value.to_s : value
-        @mini_sub_sized = mini_sub_sized if mini_sub_sized
-        @mini_sup_sized = mini_sup_sized if mini_sup_sized
+        @mini_sub_sized = mini_sub_sized
+        @mini_sup_sized = mini_sup_sized
+        @base = base
       end
 
       def ==(object)
-        object.respond_to?(:value) &&
+        object.is_a?(Number) &&
           object.value == value &&
           object.mini_sub_sized == mini_sub_sized &&
-          object.mini_sup_sized == mini_sup_sized
+          object.mini_sup_sized == mini_sup_sized &&
+          object.base == base
       end
 
       def element_order=(*); end
 
       def to_asciimath(options:)
-        format_value_with_options(options)
+        Formatter::Numbers::TextRenderer.render(
+          format_value_with_options(options), :asciimath
+        )
       end
 
       def to_mathml_without_math_tag(_, options:)
-        Utility.ox_element("mn") << format_value_with_options(options)
+        Formatter::Numbers::MathmlRenderer.render(format_value_with_options(options))
       end
 
       def to_latex(options:)
-        format_value_with_options(options)
+        Formatter::Numbers::TextRenderer.render(
+          format_value_with_options(options), :latex
+        )
       end
 
       def to_html(options:)
-        format_value_with_options(options)
+        Formatter::Numbers::TextRenderer.render(
+          format_value_with_options(options), :html
+        )
       end
 
       def to_omml_without_math_tag(_, options:)
-        [t_tag(options: options)]
+        [Formatter::Numbers::OmmlRenderer.render(format_value_with_options(options))]
       end
 
       def to_unicodemath(options:)
         return mini_sub if mini_sub_sized
         return mini_sup if mini_sup_sized
 
-        format_value_with_options(options)
+        Formatter::Numbers::TextRenderer.render(
+          format_value_with_options(options), :unicodemath
+        )
       end
 
       def insert_t_tag(_, options:)
@@ -59,17 +70,26 @@ module Plurimath
 
       def t_tag(options:)
         Utility.ox_element("t",
-                           namespace: "m") << format_value_with_options(options)
+                           namespace: "m") << formatted_value(options)
       end
 
       def nary_attr_value(options:)
-        format_value_with_options(options)
+        format_value_with_options(options).to_s
       end
 
       def validate_function_formula
         false
       end
 
+      def evaluate(_evaluator)
+        raw_value = value.to_s
+        return raw_value.to_i if raw_value.match?(/\A[+-]?\d+\z/)
+
+        Float(raw_value)
+      rescue ArgumentError
+        raise Errors::Evaluation::UnsupportedExpressionError, "number `#{raw_value}`"
+      end
+
       def mini_sized?
         mini_sub_sized || mini_sup_sized
       end
@@ -98,15 +118,16 @@ module Plurimath
         end
         return value unless formatter
 
-        if formatter.respond_to?(:format_number)
-          formatter.format_number(options[:formula], self)
-        elsif formatter.respond_to?(:format)
-          formatter.format(options[:formula], self)
-        elsif formatter.respond_to?(:localized_number)
-          formatter.localized_number(value.to_s)
-        else
-          value
-        end
+        format = options[:format] || {}
+        format = format.merge(base: base) if base && !format.key?(:base)
+
+        formatter.format_number(options[:formula], self, format: format)
+      end
+
+      private
+
+      def formatted_value(options)
+        format_value_with_options(options).to_s
       end
     end
   end

data/lib/plurimath/math/symbols/cdot.rb

@@ -12,6 +12,10 @@ module Plurimath
           html: ["⋅", "⋅"],
         }.freeze
 
+        def multiply_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "\\cdot"

data/lib/plurimath/math/symbols/div.rb

@@ -12,6 +12,10 @@ module Plurimath
           html: ["÷"],
         }.freeze
 
+        def divide_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "\\div"

data/lib/plurimath/math/symbols/hat.rb

@@ -11,6 +11,10 @@ module Plurimath
           html: ["̂", "^"],
         }.freeze
 
+        def power_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "^"

data/lib/plurimath/math/symbols/minus.rb

@@ -13,6 +13,10 @@ module Plurimath
           html: ["−", "-"],
         }.freeze
 
+        def minus_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "-"

data/lib/plurimath/math/symbols/pi.rb

@@ -10,7 +10,7 @@ module Plurimath
           mathml: ["π", "𝜋"],
           latex: ["pi", "uppi", "π", "𝜋"],
           omml: ["π", "𝜋"],
-          html: ["π", "π", "𝜋"],
+          html: ["π", "π", "𝜋", "π", "𝜋"],
         }.freeze
 
         # output methods
@@ -37,6 +37,10 @@ module Plurimath
         def to_html(**)
           "π"
         end
+
+        def reserved_constant
+          ::Math::PI
+        end
       end
     end
   end

data/lib/plurimath/math/symbols/plus.rb

@@ -13,6 +13,10 @@ module Plurimath
           html: ["+", "+"],
         }.freeze
 
+        def plus_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "+"

data/lib/plurimath/math/symbols/slash.rb

@@ -13,6 +13,10 @@ module Plurimath
           html: ["∕", "/"],
         }.freeze
 
+        def divide_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "/"

data/lib/plurimath/math/symbols/symbol.rb

@@ -108,6 +108,51 @@ module Plurimath
           false
         end
 
+        # Some parser paths emit basic operators as generic symbols instead
+        # of their semantic classes, and a hand-built Formula may hold any of
+        # them, so the generic symbol answers for every operator from its own
+        # value (parsed `+`/`^` arrive as Plus/Hat, so these are inert there).
+        def plus_operator?
+          value == "+"
+        end
+
+        def minus_operator?
+          value == "-"
+        end
+
+        def multiply_operator?
+          value == "*"
+        end
+
+        def divide_operator?
+          value == "/"
+        end
+
+        def power_operator?
+          value == "^"
+        end
+
+        # A plain symbol names a variable through its `value`. Symbol
+        # subclasses (Pi, Plus, ...) carry no `value`, so they return nil here
+        # and are never treated as variables.
+        def variable_name
+          return if reserved_constant || value.nil? || value.empty? || operator?
+
+          value
+        end
+
+        # Symbol classes that represent constants (e.g. Pi) override
+        # #reserved_constant; everything else resolves through bindings.
+        def evaluate(evaluator)
+          constant = reserved_constant
+          return constant if constant
+
+          name = variable_name
+          evaluator.unsupported(self) unless name
+
+          evaluator.value_for(name)
+        end
+
         def omml_nodes(_, options:)
           Array(t_tag(options: options))
         end

data/lib/plurimath/math/symbols/times.rb

@@ -13,6 +13,10 @@ module Plurimath
           html: ["×", "×"],
         }.freeze
 
+        def multiply_operator?
+          true
+        end
+
         # output methods
         def to_latex(**)
           "\\times"

data/lib/plurimath/math.rb

@@ -3,6 +3,7 @@
 module Plurimath
   module Math
     autoload :Core, "#{__dir__}/math/core"
+    autoload :Evaluation, "#{__dir__}/math/evaluation"
     autoload :Formula, "#{__dir__}/math/formula"
     autoload :Function, "#{__dir__}/math/function"
     autoload :InvalidTypeError, "#{__dir__}/errors/invalid_type_error"
@@ -32,7 +33,10 @@ module Plurimath
       unknown_options = options.keys - SUPPORTED_PARSE_OPTIONS
       raise_unknown_parse_options!(unknown_options) unless unknown_options.empty?
 
-      raise_unsupported_parse_option!(type, :locale) if options.key?(:locale) && !localized_parse_type?(type)
+      if options.key?(:locale) && !localized_parse_type?(type)
+        raise_unsupported_parse_option!(type,
+                                        :locale)
+      end
       options = normalize_parse_options(options)
 
       begin

data/lib/plurimath/mathml/constants.rb

@@ -174,6 +174,24 @@ module Plurimath
         "+": "+",
         "-": "-",
       }.freeze
+      # Over/under accent decorations. In MathML these are only ever expressed
+      # as <mover>/<munder> with a base (recovered from their diacritic
+      # CHARACTER), never as a bare <mi>/<mo> identifier word. So a bare token
+      # whose text is one of these names is a literal identifier (e.g. the unit
+      # "bar"), not the accent. See unitsml/unitsdb#123.
+      ACCENT_WORDS = %w[
+        bar overline ul hat vec tilde dot ddot obrace ubrace overleftrightarrow
+      ].freeze
+
+      # True when +string+ is a bare word naming an over/under accent. Such
+      # tokens are literal identifiers in MathML (the accent itself is a
+      # diacritic character inside <mover>/<munder>), so callers must not
+      # promote them to accent operators. AsciiMath/LaTeX word forms
+      # (bar(x), \bar{x}) are parsed elsewhere and never reach this predicate.
+      def self.accent_word?(string)
+        ACCENT_WORDS.include?(string&.strip)
+      end
+
       CLASSES = %w[
         mathfrak
         underset

data/lib/plurimath/number_formatter.rb

@@ -21,9 +21,26 @@ module Plurimath
       locale: @locale,
       precision: @precision,
       format: {}
+    )
+      result = formatted_number(
+        number_string,
+        locale: locale,
+        precision: precision,
+        format: format,
+      )
+      result.to_s
+    end
+
+    def formatted_number(
+      number_string,
+      locale: @locale,
+      precision: @precision,
+      format: {}
     )
       locale = supported_locale(locale)
-      source = Formatter::Numbers::Source.new(number_string)
+      format = validated_format(format)
+      base = format.fetch(:base, Formatter::Numbers::Base::DEFAULT_BASE)
+      source = Formatter::Numbers::Source.new(number_string, base: base)
       options = format_options(source, locale, precision, format)
 
       if options.notation_supported?
@@ -33,6 +50,14 @@ module Plurimath
       render_localized_number(source, options)
     end
 
+    # Formula-aware entry point. Returns a FormattedNumber,
+    # FormattedNotation, or String. Override in subclasses that need the
+    # Formula/Number context for rendering decisions; the default delegates
+    # to #formatted_number with the merged format hash.
+    def format_number(_formula, number, format: {})
+      formatted_number(number.value.to_s, format: format)
+    end
+
     def twitter_cldr_reader(locale: @locale)
       symbols_for(supported_locale(locale), {})
     end
@@ -66,8 +91,8 @@ module Plurimath
     def symbol_resolver(locale)
       Formatter::Numbers::SymbolResolver.new(
         locale,
-        localizer_symbols: localizer_symbols,
-        localize_number: localize_number,
+        localizer_symbols: validated_localizer_symbols(localizer_symbols),
+        localize_number: validated_localize_number(localize_number),
       )
     end
 
@@ -75,8 +100,43 @@ module Plurimath
       symbol_resolver(locale).resolve.merge(format)
     end
 
+    # Locale always falls back to :en for any unsupported value, including
+    # nil and non-string/symbol types; it never raises.
     def supported_locale(locale)
+      return :en unless locale.is_a?(String) || locale.is_a?(Symbol)
+
       Formatter::SupportedLocales::LOCALES.key?(locale.to_sym) ? locale.to_sym : :en
     end
+
+    def validated_format(format)
+      return {} if format.nil?
+      unless format.is_a?(Hash)
+        raise Plurimath::ConfigurationError.new(
+          :invalid_formatter_option,
+          option: :format,
+          value: format,
+          supported: "a Hash of formatter options",
+        )
+      end
+
+      format
+    end
+
+    def validated_localize_number(value)
+      return value if value.nil? || value.is_a?(String)
+
+      raise Plurimath::ConfigurationError.new(
+        :invalid_formatter_option, option: :localize_number, value: value, supported: "a String"
+      )
+    end
+
+    def validated_localizer_symbols(value)
+      return {} if value.nil?
+      return value if value.is_a?(Hash)
+
+      raise Plurimath::ConfigurationError.new(
+        :invalid_formatter_option, option: :localizer_symbols, value: value, supported: "a Hash"
+      )
+    end
   end
 end

data/lib/plurimath/omml/formula_transformation.rb

@@ -216,7 +216,8 @@ module Plurimath
       def accent_value(value)
         accent = value.first
         unless accent.is_a?(Math::Function::UnaryFunction)
-          return Math::Function::Overset.new(accent, value.last, { accent: true })
+          return Math::Function::Overset.new(accent, value.last,
+                                             { accent: true })
         end
 
         accent.attributes = { accent: true }

data/lib/plurimath/omml/translator.rb

@@ -241,7 +241,10 @@ module Plurimath
         chr = first_omml_child(pr&.chr)&.val
         value = omml_argument_value(node.e)
 
-        return group_character_above_value(chr, value) if group_character_above?(pr)
+        if group_character_above?(pr)
+          return group_character_above_value(chr,
+                                             value)
+        end
 
         group_character_below_value(chr, value)
       end

data/lib/plurimath/setup/opal.rb.erb

@@ -1,6 +1,19 @@
 # Preload Math namespace/core so symbol classes resolve correctly in Opal.
 require 'plurimath/math'
 require 'plurimath/math/core'
+require 'plurimath/math/evaluation'
+require 'plurimath/errors/evaluation'
+require 'plurimath/errors/evaluation/error'
+require 'plurimath/errors/evaluation/missing_variable_error'
+require 'plurimath/errors/evaluation/unsupported_expression_error'
+require 'plurimath/errors/evaluation/division_by_zero_error'
+require 'plurimath/errors/evaluation/invalid_binding_error'
+require 'plurimath/errors/evaluation/invalid_binding_key_error'
+require 'plurimath/errors/evaluation/math_domain_error'
+require 'plurimath/errors/evaluation/non_finite_result_error'
+require 'plurimath/math/evaluation/evaluator'
+require 'plurimath/math/evaluation/expression_parser'
+require 'plurimath/math/evaluation/iteration'
 require 'plurimath/math/symbols/symbol'
 require 'plurimath/math/symbols/paren'