plurimath 0.11.1 → 0.11.3

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

@@ -89,6 +89,13 @@ module Plurimath
           "#{first_value}∕#{second_value}" if self.options&.key?(:ldiv)
         end
 
+        def evaluate(evaluator)
+          evaluator.divide(
+            evaluator.evaluate_node(parameter_one),
+            evaluator.evaluate_node(parameter_two),
+          )
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?

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

@@ -8,6 +8,15 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          values = evaluator.function_arguments(parameter_one)
+          unless values.all?(Integer)
+            raise Errors::Evaluation::MathDomainError, "gcd requires integer arguments"
+          end
+
+          values.reduce(:gcd)
+        end
+
         def to_omml_without_math_tag(display_style, options:)
           array = []
           array << r_element("gcd", rpr_tag: false) unless hide_function_name

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

@@ -8,6 +8,15 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          values = evaluator.function_arguments(parameter_one)
+          unless values.all?(Integer)
+            raise Errors::Evaluation::MathDomainError, "lcm requires integer arguments"
+          end
+
+          values.reduce(:lcm)
+        end
+
         def to_asciimath(options:)
           first_value = " #{asciimath_value(options: options)}" if parameter_one
           "lcm#{first_value}"

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

@@ -8,6 +8,10 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          ::Math.log10(evaluator.evaluate_node(parameter_one))
+        end
+
         def to_omml_without_math_tag(display_style, options:)
           array = []
           array << r_element("lg", rpr_tag: false) unless hide_function_name

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

@@ -8,6 +8,10 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          ::Math.log(evaluator.evaluate_node(parameter_one))
+        end
+
         def to_omml_without_math_tag(display_style, options:)
           array = []
           array = r_element("ln", rpr_tag: false) unless hide_function_name

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

@@ -10,6 +10,25 @@ module Plurimath
           second_value: "supscript",
         }.freeze
 
+        # `log` carries its base/exponent but not its argument; the parser
+        # binds the following fenced group via #evaluate_with_argument, so a
+        # bare `log` is unsupported.
+        def evaluate(evaluator)
+          evaluator.unsupported(self)
+        end
+
+        def evaluate_with_argument(evaluator, argument)
+          base = parameter_one ? evaluator.evaluate_node(parameter_one) : 10
+          unless base.positive? && base != 1
+            raise Errors::Evaluation::MathDomainError,
+                  "log base must be a positive number other than 1"
+          end
+
+          result = ::Math.log(evaluator.evaluate_node(argument), base)
+          result = evaluator.power(result, evaluator.evaluate_node(parameter_two)) if parameter_two
+          result
+        end
+
         def to_asciimath(options:)
           if parameter_one
             first_value = "_#{wrapped(parameter_one,

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

@@ -8,6 +8,10 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          evaluator.function_arguments(parameter_one).max
+        end
+
         def to_omml_without_math_tag(display_style, options:)
           array = []
           array << r_element("max", rpr_tag: false) unless hide_function_name

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

@@ -8,6 +8,10 @@ module Plurimath
           false
         end
 
+        def evaluate(evaluator)
+          evaluator.function_arguments(parameter_one).min
+        end
+
         def to_omml_without_math_tag(display_style, options:)
           array = []
           array << r_element("min", rpr_tag: false) unless hide_function_name

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

@@ -10,6 +10,21 @@ module Plurimath
           second_value: "argument",
         }.freeze
 
+        def evaluate(evaluator)
+          evaluator.modulo(
+            evaluator.evaluate_node(parameter_one),
+            evaluator.evaluate_node(parameter_two),
+          )
+        end
+
+        # `-a mod b` negates the dividend, matching `(-a) mod b`.
+        def evaluate_negated(evaluator)
+          evaluator.modulo(
+            -evaluator.evaluate_node(parameter_one),
+            evaluator.evaluate_node(parameter_two),
+          )
+        end
+
         def to_asciimath(options:)
           first_value = parameter_one&.to_asciimath(options: options)
           second_value = parameter_two&.to_asciimath(options: options)

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

@@ -80,6 +80,16 @@ module Plurimath
           end
         end
 
+        # Nested Power trees evaluate literally: `Power(Power(2, 3), 2)` is
+        # `(2^3)^2`, whether it came from explicit MathML nesting or a
+        # left-nested source chain.
+        def evaluate(evaluator)
+          evaluator.power(
+            evaluator.evaluate_node(parameter_one),
+            evaluator.evaluate_node(parameter_two),
+          )
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?

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

@@ -12,6 +12,16 @@ module Plurimath
           second_value: "supscript",
         }.freeze
 
+        def evaluate(evaluator)
+          if parameter_one.nil? || parameter_two.nil? || parameter_three.nil?
+            evaluator.unsupported(self)
+          end
+
+          Evaluation::Iteration
+            .new(evaluator, parameter_one, parameter_two, parameter_three)
+            .accumulate(1, :*)
+        end
+
         def initialize(parameter_one = nil,
                        parameter_two = nil,
                        parameter_three = nil,

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

@@ -51,6 +51,13 @@ module Plurimath
           second_value = parameter_two.to_unicodemath(options: options) if parameter_two
           "√(#{first_value}&#{second_value})"
         end
+
+        def evaluate(evaluator)
+          evaluator.power(
+            evaluator.evaluate_node(parameter_two),
+            evaluator.divide(1.0, evaluator.evaluate_node(parameter_one)),
+          )
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          evaluator.divide(1.0, ::Math.cos(evaluator.evaluate_node(parameter_one)))
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          evaluator.divide(1.0, ::Math.cosh(evaluator.evaluate_node(parameter_one)))
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          ::Math.sin(evaluator.evaluate_node(parameter_one))
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          ::Math.sinh(evaluator.evaluate_node(parameter_one))
+        end
       end
     end
   end

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

@@ -42,6 +42,10 @@ module Plurimath
         def to_unicodemath(options:)
           "√#{unicodemath_parens(parameter_one, options: options)}"
         end
+
+        def evaluate(evaluator)
+          ::Math.sqrt(evaluator.evaluate_node(parameter_one))
+        end
       end
     end
   end

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

@@ -13,6 +13,16 @@ module Plurimath
           third_value: "term",
         }.freeze
 
+        def evaluate(evaluator)
+          if parameter_one.nil? || parameter_two.nil? || parameter_three.nil?
+            evaluator.unsupported(self)
+          end
+
+          Evaluation::Iteration
+            .new(evaluator, parameter_one, parameter_two, parameter_three)
+            .accumulate(0, :+)
+        end
+
         def initialize(parameter_one = nil,
                        parameter_two = nil,
                        parameter_three = nil,

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          ::Math.tan(evaluator.evaluate_node(parameter_one))
+        end
       end
     end
   end

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

@@ -7,6 +7,10 @@ module Plurimath
         def validate_function_formula
           false
         end
+
+        def evaluate(evaluator)
+          ::Math.tanh(evaluator.evaluate_node(parameter_one))
+        end
       end
     end
   end

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

@@ -66,6 +66,23 @@ module Plurimath
           false
         end
 
+        # OMML emits variable text runs as Text nodes. Only a plain, non-blank
+        # string names a variable; rich content (arrays/formulas) or a missing
+        # value does not.
+        def variable_name
+          return unless parameter_one.is_a?(String)
+
+          stripped = parameter_one.strip
+          stripped unless stripped.empty?
+        end
+
+        def evaluate(evaluator)
+          name = variable_name
+          evaluator.unsupported(self) unless name
+
+          evaluator.value_for(name)
+        end
+
         def to_asciimath_math_zone(spacing, _, _, options:)
           "#{spacing}#{to_asciimath(options: options)} text\n"
         end

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,25 +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,
-                                     **format_kwargs(options[:format]))
-        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
 
-      # Empty splat is silently dropped by Ruby, so simple formatter signatures still work.
-      def format_kwargs(format)
-        return {} unless format.is_a?(Hash) && !format.empty?
-
-        { format: format }
+      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"

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