plurimath 0.11.0 → 0.11.3

data/lib/plurimath/math/evaluation/iteration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    module Evaluation
+      # Evaluates bounded Sum/Prod iterations: parses the `i=1` lower bound,
+      # validates the integer bounds and step limit, then folds the body with
+      # the index temporarily bound.
+      class Iteration
+        def initialize(evaluator, lower, upper, body)
+          @evaluator = evaluator
+          @lower = lower
+          @upper = upper
+          @body = body
+        end
+
+        def accumulate(initial, operation)
+          name, from = index_definition
+          to = evaluator.evaluate_node(upper)
+          validate_bounds(from, to)
+
+          (from..to).reduce(initial) do |accumulator, index|
+            accumulator.public_send(operation, body_value(name, index))
+          end
+        end
+
+        private
+
+        attr_reader :evaluator, :lower, :upper, :body
+
+        # Parses `i=1` style lower bounds into the index name and its start.
+        def index_definition
+          tokens = lower.is_a?(Formula) ? lower.value : Array(lower)
+          index = tokens.first
+          if index.is_a?(Core) && index.reserved_constant
+            evaluator.unsupported("reserved constant as iteration index")
+          end
+          name = index.is_a?(Core) ? index.variable_name : nil
+          unless name && tokens[1].is_a?(Symbols::Equal)
+            evaluator.unsupported("malformed iteration bounds")
+          end
+
+          [name, evaluator.evaluate_nodes(tokens[2..])]
+        end
+
+        def validate_bounds(from, to)
+          unless from.is_a?(Integer) && to.is_a?(Integer)
+            raise Errors::Evaluation::MathDomainError, "iteration bounds must be integers"
+          end
+
+          limit = Plurimath.configuration.evaluation_max_iterations
+          return if limit.nil? || (to - from + 1) <= limit
+
+          evaluator.unsupported("iteration range larger than #{limit} steps")
+        end
+
+        def body_value(name, index)
+          evaluator.with_binding(name, index) { evaluator.evaluate_node(body) }
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/evaluation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "plurimath/errors/evaluation"
+
+module Plurimath
+  module Math
+    module Evaluation
+      autoload :Evaluator, "#{__dir__}/evaluation/evaluator"
+      autoload :ExpressionParser, "#{__dir__}/evaluation/expression_parser"
+      autoload :Iteration, "#{__dir__}/evaluation/iteration"
+    end
+  end
+end

data/lib/plurimath/math/formula.rb

@@ -54,6 +54,15 @@ module Plurimath
           object.left_right_wrapper == left_right_wrapper
       end
 
+      def evaluate(bindings = {})
+        hash = bindings.to_hash if bindings.respond_to?(:to_hash)
+        unless hash.is_a?(Hash)
+          raise ArgumentError, "bindings must be a Hash-like object"
+        end
+
+        Evaluation::Evaluator.new(self, hash).evaluate
+      end
+
       def to_asciimath(formatter: nil, unitsml: {}, options: nil)
         options ||= { formatter: formatter, unitsml: unitsml }.compact
         options[:formula] ||= self

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

@@ -39,6 +39,10 @@ module Plurimath
           "⒜#{unicodemath_parens(parameter_one, options: options)}"
         end
 
+        def evaluate(evaluator)
+          evaluator.evaluate_node(parameter_one).abs
+        end
+
         def intent_names
           { name: "absolute-value" }
         end

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

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

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

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

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

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

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

@@ -39,6 +39,10 @@ module Plurimath
           "#{first_value}#{parameter_one&.to_unicodemath(options: options)}#{second_value}"
         end
 
+        def evaluate(evaluator)
+          evaluator.evaluate_node(parameter_one).ceil
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -116,6 +116,10 @@ module Plurimath
           "#{unicode_open_paren(options: options)}#{fenced_value}#{unicode_close_paren(options: options)}"
         end
 
+        def evaluate(evaluator)
+          evaluator.evaluate_nodes(parameter_two)
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true,
 options:)
           filtered_values(parameter_two,

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

@@ -36,6 +36,10 @@ module Plurimath
           "#{first_value}#{parameter_one&.to_unicodemath(options: options)}#{second_value}"
         end
 
+        def evaluate(evaluator)
+          evaluator.evaluate_node(parameter_one).floor
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -14,7 +14,7 @@ module Plurimath
         def to_mathml_without_math_tag(intent, options:)
           mover = ox_element("mover")
           first_value = parameter_one&.to_mathml_without_math_tag(intent,
-                                                                    options: options)
+                                                                  options: options)
           if attributes && attributes[:accent]
             mover[:accent] =
               attributes[:accent]
@@ -36,7 +36,7 @@ module Plurimath
           else
             symbol = Symbols::Symbol.new("\u20e1")
             Overset.new(parameter_one, symbol).to_omml_without_math_tag(true,
-                                                                          options: options)
+                                                                        options: options)
           end
         end
 

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