plurimath 0.8.10 → 0.8.11

data/lib/plurimath/math/formula.rb

@@ -11,6 +11,13 @@ module Plurimath
         mathml
         asciimath
       ].freeze
+      POWER_BASE_CLASSES = %w[powerbase power base].freeze
+      DERIVATIVE_CONSTS = [
+        "𝑑",
+        "ⅅ",
+        "ⅆ",
+        "d",
+      ].freeze
 
       def initialize(
         value = [],
@@ -39,8 +46,8 @@ module Plurimath
         parse_error!(:asciimath)
       end
 
-      def to_mathml(display_style: displaystyle, split_on_linebreak: false)
-        return line_breaked_mathml(display_style) if split_on_linebreak
+      def to_mathml(display_style: displaystyle, split_on_linebreak: false, intent: false)
+        return line_breaked_mathml(display_style, intent) if split_on_linebreak
 
         math_attrs = {
           xmlns: "http://www.w3.org/1998/Math/MathML",
@@ -49,7 +56,7 @@ module Plurimath
         style_attrs = { displaystyle: boolean_display_style(display_style) }
         math  = ox_element("math", attributes: math_attrs)
         style = ox_element("mstyle", attributes: style_attrs)
-        Utility.update_nodes(style, mathml_content)
+        Utility.update_nodes(style, mathml_content(intent))
         Utility.update_nodes(math, [style])
         unitsml_post_processing(math.nodes, math)
         dump_nodes(math, indent: 2)
@@ -57,22 +64,26 @@ module Plurimath
         parse_error!(:mathml)
       end
 
-      def line_breaked_mathml(display_style)
+      def line_breaked_mathml(display_style, intent)
         new_line_support.map do |formula|
-          formula.to_mathml(display_style: display_style)
+          formula.to_mathml(display_style: display_style, intent: intent)
         end.join
       end
 
-      def to_mathml_without_math_tag
-        return mathml_content unless left_right_wrapper
+      def to_mathml_without_math_tag(intent)
+        return mathml_content(intent) unless left_right_wrapper
 
-        mrow = ox_element("mrow")
+        mathml_value = mathml_content(intent)
+        attributes = intent_attribute(mathml_value) if intent
+        mrow = ox_element("mrow", attributes: attributes)
         mrow[:unitsml] = true if unitsml
-        Utility.update_nodes(mrow, mathml_content)
+        Utility.update_nodes(mrow, mathml_value)
       end
 
-      def mathml_content
-        value.map(&:to_mathml_without_math_tag)
+      def mathml_content(intent)
+        nodes = value.map { |val| val.to_mathml_without_math_tag(intent) }
+        intent_post_processing(nodes, intent) if intent
+        nodes
       end
 
       def to_latex
@@ -335,6 +346,318 @@ module Plurimath
           valid_previous?(node) if node.xml_node?
         end
       end
+
+      def intent_attribute(mathml)
+        return unless mathml || value.length != 2
+        return unless valid_first_parameter?(value.first)
+
+        { intent: ":function" }
+      end
+
+      def valid_first_parameter?(param)
+        undef_functions = UnicodeMath::Constants::UNDEF_UNARY_FUNCTIONS
+        return true if param.is_a?(Symbols::Symbol) && undef_functions.include?(param.value)
+        return unless POWER_BASE_CLASSES.include?(param.class_name)
+
+        param.parameter_one.is_a?(Function::UnaryFunction) ||
+          param.parameter_one.is_a?(Function::Lim)
+      end
+
+      def intent_post_processing(nodes, intent)
+        mrow = Utility.update_nodes(ox_element("mrow"), nodes)
+        upcase_dd_derivative(nodes) if validate_upcase_dd_derivatives?(nodes)
+        subsup_dd_derivative(nodes) if validate_subsup_dd_derivatives?(nodes)
+        partial_derivative(nodes) if valid_partial_derivative?(nodes)
+        update_partial_derivative_nodes(nodes) unless mrow.locate("*/mfrac/@arg").empty?
+      end
+
+      # Partial derivative nodes begin
+      def update_partial_derivative_nodes(nodes)
+        nodes.reduce do |first, second|
+          if valid_partial_node(first)
+            if %w[mfrac mo].include?(second.name)
+              first["intent"].gsub!("$f", "")
+            else
+              second["arg"] = "f"
+            end
+          end
+          second
+        end
+      end
+
+      def valid_partial_node(node)
+        return unless node.name == "mfrac"
+
+        node["intent"]&.start_with?(":partial-derivative") &&
+          !node.locate("*/@arg").include?("f")
+      end
+
+      def valid_partial_derivative?(nodes)
+        valid = false
+        nodes.reduce do |first, second|
+          next second unless first.name == "msub"
+
+          valid = true if first.nodes[0].nodes[0] == "∂" && second
+          second
+        end
+        valid
+      end
+
+      def partial_derivative(nodes)
+        nodes.each.with_index do |first, index|
+          second = nodes[index+1]
+          next second unless first.name == "msub" && first.nodes.first.nodes.include?("∂")
+
+          first["intent"] = partial_derivative_intent(first)
+          f_arg(nodes, index+1)
+        end
+      end
+
+      def partial_derivative_intent(first)
+        first_node = first.nodes.last
+        case first_node.name
+        when "mi"
+          first_arg, second_arg = [1, encode(first_node.nodes.first)]
+        when "mn"
+          first_arg, second_arg = numeric_encoding(node)
+        when "mrow"
+          str = ""
+          first_node.nodes.each do |node|
+            case node.name
+            when "mi"
+              str += encode(node.nodes.first)
+            when "mn"
+              str += numeric_encoding(node).last if str.empty?
+              break
+            end
+          end
+          first_arg = str.include?(",") ? str.split(",").length : str.length
+          second_arg = str.include?(",") ? str : str.split("").join(",")
+        when "msup"
+          nodes = first_node.nodes
+          str = ""
+          case nodes.first.name
+          when "mrow"
+            nodes.first.nodes.each do |node|
+              case node.name
+              when "mi"
+                str += encode(node.nodes.first)
+              when "mn"
+                str += numeric_encoding(node).last if str.empty?
+                break
+              end
+            end
+          when "mi"
+            str += encode(node.nodes.first)
+          end
+          first_arg = str.include?(",") ? str.split(",").length : str.length
+          second_arg = str.include?(",") ? str : str.split("").join(",")
+          prime_str = encode(nodes.last.nodes.first) if valid_prime?(nodes.last)
+          second_arg.insert(-1, prime_str) unless second_arg.match?(/[0-9]$/)
+        end
+        ":partial-derivative(#{first_arg},$f,#{second_arg})"
+      end
+
+      def f_arg(tag_nodes, index)
+        nodes = []
+        while index <= tag_nodes.length
+          node = tag_nodes[index]
+          break unless node
+
+          case node.name
+          when "mrow"
+            nodes << tag_nodes.delete_at(index)
+            break
+          when "mi"
+            nodes << tag_nodes.delete_at(index)
+          when "mn"
+            nodes << tag_nodes.delete_at(index) if nodes.empty?
+            break
+          else
+            break
+          end
+        end
+        mrow = if nodes.length == 1
+                 node = nodes.first
+                 node["arg"] = "f"
+                 node
+               else
+                 Utility.update_nodes(
+                   ox_element("mrow", attributes: { arg: "f" }),
+                   nodes,
+                 )
+               end
+        tag_nodes.insert(index, mrow)
+      end
+      # Partial derivative nodes end
+
+      # Dd derivative nodes begin
+      def validate_subsup_dd_derivatives?(nodes)
+        nodes.find.with_index do |node, index|
+          next unless %w[msub msup msubsup].include?(node.name)
+
+          next_node = nodes[index + 1]
+          next unless next_node
+          next if next_node.name == "mo"
+
+          DERIVATIVE_CONSTS.include?(node.nodes.first.nodes.first)
+        end
+      end
+
+      def validate_upcase_dd_derivatives?(nodes)
+        return unless nodes[0]&.nodes&.first == "&#x2145;"
+        return unless nodes[1].name == "mi"
+
+        true
+      end
+
+      def upcase_dd_derivative(nodes)
+        mrow_nodes = []
+        while true
+          node = nodes[1]
+          case node.name
+          when "mi"
+            mrow_nodes << nodes.delete_at(1)
+            next
+          when "mrow"
+            second_arg = mrow_nodes.map { |node| encode(node.nodes.first) }.join
+            third_arg  = upcase_dd_intent_name(node.nodes[1..-2])
+            mrow_nodes << nodes.delete_at(1)
+            break
+          end
+          break
+        end
+        intent_name = ":derivative(1,#{second_arg},#{third_arg})"
+        mrow = ox_element("mrow", attributes: { intent: intent_name })
+        nodes.insert(0, Utility.update_nodes(mrow, mrow_nodes))
+      end
+
+      def subsup_dd_derivative(nodes)
+        iteration = 0
+        return unless DERIVATIVE_CONSTS.include?(nodes[iteration].nodes[iteration].nodes.first)
+
+        while iteration < nodes.length do
+          node = nodes[iteration]
+          next iteration += 1 unless node.nodes[0].is_a?(Plurimath::XmlEngine::Ox::Element)
+
+          if DERIVATIVE_CONSTS.include?(node.nodes[0]&.nodes&.first)
+            iteration += 1
+            node["intent"] = ":derivative#{derivative_intent_name(node.nodes[1], nodes[iteration..-1], type: node.name)}"
+            next_node = nodes[iteration]
+            case next_node.name
+            when "mi", "mrow"
+              if ["mi", "mrow"].include?(nodes[iteration + 1].name)
+                wrap_in_mrow(nodes[iteration..-1])
+              else
+                next_node["arg"] = "f"
+              end
+            end
+          end
+          iteration += 1
+        end
+      end
+
+      def derivative_intent_name(node, next_nodes, type:)
+        case type
+        when "msub"
+          first_value, second_value = sub_intent_content(node)
+          "(#{first_value},$f,#{second_value})"
+        when "msup"
+          "(#{sup_intent_content(node)},$f,#{sup_second_content(next_nodes)})"
+        end
+      end
+
+      def sub_intent_content(node)
+        return ["1", encode(node.nodes[0])] if node.name == "mi"
+        return numeric_encoding(node) if node.name == "mn"
+        return ["1"] if node["intent"] == "fenced"
+        return unless node.name == "mrow"
+        return ["1"] unless node.nodes.all? { |element| element.name == "mi" }
+      end
+
+      def sup_intent_content(node)
+        return encode(first_node) if node.name == "mi"
+        return node.nodes[0] if node.name == "mn"
+        return "$n" if node.name == "mrow"
+      end
+
+      def sup_second_content(next_nodes)
+        fence_node = nil
+        next_nodes.each do |node|
+          break if fence_node
+
+          next if %w[mi mn].include?(node.name)
+          fence_node = node if node.name == "mrow" && node["intent"] == ":fenced"
+          break unless %w[mi mn].include?(node.name)
+        end
+        return if fence_node.nil?
+
+        nodes = fence_node.nodes[1..-1]
+        sliced_nodes = nodes.slice_before { |node| node.name == "mn" }
+        str = ""
+        sliced_nodes.to_a.last.each do |node|
+          break unless %w[msub msup msubsup mi mn].include?(node.name)
+
+          case node.name
+          when "msub", "msup", "msubsup"
+            powerbase_nodes = node.nodes
+            str += encode(powerbase_nodes.first.nodes.first)
+            str += encode(powerbase_nodes.last.nodes.first) if valid_prime?(powerbase_nodes.last)
+          when "mi", "mn"
+            str += node.nodes.first
+          end
+        end
+        str
+      end
+
+      def wrap_in_mrow(nodes)
+        mrow = ox_element("mrow", attributes: { arg: "f" })
+        row_nodes = []
+        loop do
+          node = nodes.shift if ["mi", "mrow"].include?(nodes[0].name)
+          row_nodes << node
+          next if node.name == "mi"
+          break if node.name == "mrow"
+        end
+        Utility.update_nodes(mrow, row_nodes)
+      end
+
+      def numeric_encoding(node)
+        nodes = node.nodes[0].split("")
+        [nodes.length, nodes.join(",")]
+      end
+
+      def valid_prime?(node)
+        Utility.primes_constants.values.any? { |prime| prime == node.nodes.first }
+      end
+
+      def encode(str)
+        Utility.html_entity_to_unicode(str)
+      end
+
+      def upcase_dd_intent_name(nodes)
+        str = ""
+        nodes.each do |node|
+          case node.name
+          when "mi"
+            str += node.nodes.first
+          when "mn"
+            str = node.nodes.first
+          when "msub", "msup", "msubsup"
+            next unless %w[mi mn].include?(node.nodes[0].name)
+
+            str = node.nodes[0] if node.nodes.first.name == "mn"
+            str += node.nodes[0].nodes[0] if node.nodes.first.name == "mi"
+            sup_index = node.name == "msubsup" ? 2 : 1
+            str += node.nodes[sup_index].nodes[0] if valid_prime?(node.nodes[sup_index])
+          else
+            str = "" if node.name == "mfrac"
+            break
+          end
+        end
+        encode(str)
+      end
+      # Dd derivative nodes end
     end
   end
 end

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

@@ -8,12 +8,13 @@ module Plurimath
       class Abs < UnaryFunction
         attr_accessor :open_paren, :close_paren
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           symbol = Utility.ox_element("mo") << "|"
-          first_value = mathml_value
+          first_value = mathml_value(intent)
           first_value = first_value&.insert(0, symbol) unless open_paren
           first_value << symbol unless close_paren
-          Utility.update_nodes(ox_element("mrow"), first_value)
+          mrow = Utility.update_nodes(ox_element("mrow"), first_value)
+          intentify(mrow, intent, func_name: :abs, intent_name: :"absolute-value")
         end
 
         def to_omml_without_math_tag(display_style)

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

@@ -6,8 +6,8 @@ module Plurimath
   module Math
     module Function
       class Arg < BinaryFunction
-        def to_mathml_without_math_tag
-          first_value = parameter_one.to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
+          first_value = parameter_one.to_mathml_without_math_tag(intent)
           first_value.attributes[:arg] = Utility.html_entity_to_unicode(parameter_two.value)
           first_value
         end

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

@@ -23,7 +23,7 @@ module Plurimath
           "\\overline#{first_value}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           mo_tag = Utility.ox_element("mo") << "&#xaf;"
           return mo_tag unless parameter_one
 
@@ -32,7 +32,7 @@ module Plurimath
           Utility.update_nodes(
             mover_tag,
             [
-              parameter_one&.to_mathml_without_math_tag,
+              parameter_one&.to_mathml_without_math_tag(intent),
               mo_tag,
             ],
           )

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

@@ -31,12 +31,12 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag
-          tag_name = (Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub")
+        def to_mathml_without_math_tag(intent)
+          tag_name = Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub"
           sub_tag = Utility.ox_element("m#{tag_name}")
           mathml_value = []
-          mathml_value << validate_mathml_fields(parameter_one)
-          mathml_value << validate_mathml_fields(parameter_two)
+          mathml_value << validate_mathml_fields(parameter_one, intent)
+          mathml_value << validate_mathml_fields(parameter_two, intent)
           Utility.update_nodes(sub_tag, mathml_value)
         end
 

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

@@ -22,11 +22,11 @@ module Plurimath
             object.parameter_two == parameter_two
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           mrow_tag = Utility.ox_element("mrow")
           mo_tag = Utility.ox_element("mo") << invert_unicode_symbols.to_s
-          first_value = parameter_one&.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two&.to_mathml_without_math_tag if parameter_two
+          first_value = parameter_one&.to_mathml_without_math_tag(intent) if parameter_one
+          second_value = parameter_two&.to_mathml_without_math_tag(intent) if parameter_two
           Utility.update_nodes(
             mrow_tag,
             [

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

@@ -6,12 +6,12 @@ module Plurimath
   module Math
     module Function
       class Cancel < UnaryFunction
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           cancel_tag = Utility.ox_element(
             "menclose",
             attributes: { notation: "updiagonalstrike" },
           )
-          first_value = parameter_one&.to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag(intent)
           Utility.update_nodes(cancel_tag, [first_value])
         end
 

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

@@ -12,8 +12,8 @@ module Plurimath
           "{\\lceil #{latex_value} \\rceil}"
         end
 
-        def to_mathml_without_math_tag
-          first_value = mathml_value
+        def to_mathml_without_math_tag(intent)
+          first_value = mathml_value(intent)
           first_value = first_value&.insert(0, paren_node("⌈")) unless open_paren
           first_value = first_value << paren_node("&#x2309;") unless close_paren
           Utility.update_nodes(ox_element("mrow"), first_value)

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

@@ -26,14 +26,14 @@ module Plurimath
           "color#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           color_value = parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "")
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
               attributes: { attr_key => color_value },
             ),
-            [parameter_two&.to_mathml_without_math_tag],
+            [parameter_two&.to_mathml_without_math_tag(intent)],
           )
         end
 

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

@@ -13,11 +13,11 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           second_value = Utility.ox_element("mo") << ".."
           Utility.update_nodes(
             Utility.ox_element("mover", attributes: { accent: "true" }),
-            mathml_value << second_value,
+            mathml_value(intent) << second_value,
           )
         end
 

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

@@ -13,11 +13,11 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_mathml_without_math_tag
-          dot_tag = (Utility.ox_element("mo") << ".")
+        def to_mathml_without_math_tag(intent)
+          dot_tag = Utility.ox_element("mo") << "."
           return dot_tag unless parameter_one
 
-          first_value = parameter_one&.to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag(intent)
           dot_tag = (Utility.ox_element("mo") << ".")
           over_tag = Utility.ox_element("mover")
           over_tag[:accent] = attributes[:accent] if attributes && attributes[:accent]