plurimath 0.8.10 → 0.8.12

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

@@ -28,13 +28,16 @@ module Plurimath
           "#{first_value}#{parameter_two&.map(&:to_asciimath)&.join(' ')}#{third_value}"
         end
 
-        def to_mathml_without_math_tag
-          first_value = Utility.ox_element("mo", attributes: options&.dig(:open_paren)) << (mathml_paren(parameter_one) || "")
-          second_value = parameter_two&.map(&:to_mathml_without_math_tag) || []
-          third_value = Utility.ox_element("mo", attributes: options&.dig(:close_paren)) << (mathml_paren(parameter_three) || "")
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            (second_value.insert(0, first_value) << third_value),
+        def to_mathml_without_math_tag(intent)
+          first_value = ox_element("mo", attributes: options&.dig(:open_paren)) << (mathml_paren(parameter_one, intent) || "")
+          third_value = ox_element("mo", attributes: options&.dig(:close_paren)) << (mathml_paren(parameter_three, intent) || "")
+          mrow_value = Array(mathml_value(intent)).insert(0, first_value) << third_value
+          fenced = Utility.update_nodes(ox_element("mrow"), mrow_value)
+          intentify(
+            fenced,
+            intent,
+            func_name: :interval_fence,
+            intent_name: intent_value(mrow_value),
           )
         end
 
@@ -90,22 +93,22 @@ module Plurimath
 
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           filtered_values(parameter_two, lang: :asciimath).map.with_index(1) do |object, index|
-            last = index == @values.length
-            object.to_asciimath_math_zone(spacing, last, indent)
+            new_last = index == @values.length && last
+            object.to_asciimath_math_zone(spacing, new_last, indent)
           end
         end
 
         def to_latex_math_zone(spacing, last = false, indent = true)
           filtered_values(parameter_two, lang: :latex).map.with_index(1) do |object, index|
-            last = index == @values.length
-            object.to_latex_math_zone(spacing, last, indent)
+            new_last = index == @values.length && last
+            object.to_latex_math_zone(spacing, new_last, indent)
           end
         end
 
         def to_mathml_math_zone(spacing, last = false, indent = true)
           filtered_values(parameter_two, lang: :mathml).map.with_index(1) do |object, index|
-            last = index == @values.length
-            object.to_mathml_math_zone(spacing, last, indent)
+            new_last = index == @values.length && last
+            object.to_mathml_math_zone(spacing, new_last, indent)
           end
         end
 
@@ -115,6 +118,13 @@ module Plurimath
           end
         end
 
+        def to_unicodemath_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two, lang: :unicodemath).map.with_index(1) do |object, index|
+            new_last = index == @values.length && last
+            object.to_unicodemath_math_zone(spacing, new_last, indent)
+          end
+        end
+
         def line_breaking(obj)
           field_values = result(Array(parameter_two))
           return unless field_values.length > 1
@@ -166,9 +176,9 @@ module Plurimath
           paren
         end
 
-        def mathml_paren(field)
+        def mathml_paren(field, intent)
           unicodemath_syntax = ["&#x3016;", "&#x3017;", "&#x2524;", "&#x251c;"]
-          paren = symbol_or_paren(field, lang: :mathml)
+          paren = symbol_or_paren(field, lang: :mathml, intent: intent)
           (paren&.include?(":") || unicodemath_syntax.include?(paren)) ? "" : paren
         end
 
@@ -227,18 +237,114 @@ module Plurimath
           parameter_one.is_a?(Math::Symbols::Paren::Vert)
         end
 
-        def symbol_or_paren(field, lang:)
+        def symbol_or_paren(field, lang:, intent: false)
           return field&.value unless field.is_a?(Math::Symbols::Paren)
 
           case lang
           when :mathml, :html
-            field.to_mathml_without_math_tag.nodes.first
+            field.to_mathml_without_math_tag(intent).nodes.first
           when :latex
             field.to_latex
           when :omml
             field.to_omml_without_math_tag(true)
           end
         end
+
+        def intent_value(value)
+          return "binomial-coefficient" if binomial_coefficient?(value)
+
+          open_paren = symbol_or_paren(parameter_one, lang: :latex)
+          close_paren = symbol_or_paren(parameter_three, lang: :latex)
+          return "fenced" unless interval_intent?(value, open_paren, close_paren)
+
+          interval_intent(value, open_paren, close_paren)
+        end
+
+        def binomial_coefficient?(value)
+          parameter_two&.first&.is_a?(Frac) &&
+            parameter_two&.first&.options&.dig(:choose)
+        end
+
+        def interval_intent(value, open_paren, close_paren)
+          case open_paren
+          when "("
+            'open-closed-interval' if close_paren == ']'
+          when "["
+            return 'closed-interval' if close_paren == ']'
+
+            'closed-open-interval' if (close_paren == '[' || close_paren == ')')
+          when "]"
+            return 'open-closed-interval' if close_paren == ']'
+
+            'open-interval' if close_paren == '['
+          end
+        end
+
+        def interval_intent?(value, open_paren, close_paren)
+          return if value.length != 5
+          return unless interval_intent_value?(value)
+
+          case open_paren
+          when "(" then close_paren == ']'
+          when "]" then ['[', ']'].include?(close_paren)
+          when "[" then ['[', ']', ')'].include?(close_paren)
+          end
+        end
+
+        def interval_intent_value?(value)
+          return unless value[2].nodes.first == ","
+
+          valid_intent_value?(value[1]) &&
+            valid_intent_value?(value[3])
+        end
+
+        def valid_intent_value?(node)
+          case node.name
+          when "mrow"
+            return true if all_specific_nodes?(node.nodes, "mn")
+
+            all_specific_nodes?(node.nodes, ["mo", "mi"])
+          when "mi", "mo" then match_node_value?(node, /[A-Za-z]/)
+          when "mn" then match_node_value?(node, /[0-9]/)
+          end
+        end
+
+        def all_specific_nodes?(nodes, array)
+          nodes.all? { |node| Array(array).include?(node.name) }
+        end
+
+        def match_node_value?(node, regex)
+          node.nodes.first.match?(regex)
+        end
+
+        def mathml_value(intent)
+          nodes = parameter_two&.map { |object| object&.to_mathml_without_math_tag(intent) }
+          if intent
+            mrow = Utility.update_nodes(ox_element("mrow"), nodes)
+            update_partial_derivative(nodes) unless mrow.locate("*/mfrac/@intent").empty?
+          end
+          nodes
+        end
+
+        def update_partial_derivative(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
       end
     end
   end

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

@@ -12,8 +12,8 @@ module Plurimath
           "{\\lfloor #{parameter_one.to_latex} \\rfloor}"
         end
 
-        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)
           value_array = [first_value]
           value_array.insert(0, (ox_element("mo") << "&#x230a;")) unless open_paren
           value_array << (ox_element("mo") << "&#x230b;") unless close_paren

data/lib/plurimath/math/function/font_style/bold.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathbf{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "bold" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/double_struck.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathbb{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "double-struck" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/fraktur.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathfrak{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "fraktur" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/italic.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathit{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "italic" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/monospace.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathtt{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "monospace" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/normal.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathrm{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "normal" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/sans-serif.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathsf{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "sans-serif" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

data/lib/plurimath/math/function/font_style/script.rb

@@ -20,13 +20,13 @@ module Plurimath
             "\\mathcal{#{parameter_one&.to_latex}}"
           end
 
-          def to_mathml_without_math_tag
+          def to_mathml_without_math_tag(intent)
             Utility.update_nodes(
               Utility.ox_element(
                 "mstyle",
                 attributes: { mathvariant: "script" },
               ),
-              [parameter_one&.to_mathml_without_math_tag],
+              [parameter_one&.to_mathml_without_math_tag(intent)],
             )
           end
 

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

@@ -10,8 +10,8 @@ module Plurimath
           parameter_one&.to_asciimath
         end
 
-        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)
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
@@ -120,6 +120,16 @@ module Plurimath
           end
         end
 
+        def to_unicodemath_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{dump_unicodemath(self)}\" function apply\n",
+            "#{new_spacing}|_ \"#{font_family(unicode: true)}\" font family\n",
+          ]
+          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr })
+          new_arr
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           return unless obj.value_exist?

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

@@ -31,15 +31,17 @@ module Plurimath
           "frac#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           tag_name = hide_function_name ? "mrow" : "mfrac"
           mathml_value = [
-            parameter_one&.to_mathml_without_math_tag,
-            parameter_two&.to_mathml_without_math_tag,
+            parameter_one&.to_mathml_without_math_tag(intent),
+            parameter_two&.to_mathml_without_math_tag(intent),
           ]
           frac_tag = ox_element(tag_name)
-          frac_tag.set_attr(options) if tag_name == "mfrac" && options
+          frac_tag.set_attr(options.reject { |opt| opt == :choose }) if tag_name == "mfrac" && options
           Utility.update_nodes(frac_tag, mathml_value)
+          update_derivative(frac_tag, mathml_value[0], mathml_value[1]) if intent
+          intentify(frac_tag, intent, func_name: :frac)
         end
 
         def to_latex
@@ -119,6 +121,36 @@ module Plurimath
           frac_array = [parameter_one.value.to_i, parameter_two.value.to_i]
           UnicodeMath::Constants::UNICODE_FRACTIONS.key(frac_array)
         end
+
+        def update_derivative(tag, num, den)
+          return if %w[mi mo mn].include?(num&.name)
+
+          intent = num.is_a?(::Array) ? num.first["intent"] : num&.nodes&.first["intent"]
+          return unless intent
+          return unless intent.start_with?(":derivative") && intent.end_with?(",)")
+
+          num.nodes.first["intent"].gsub!(/,\)$/, ",#{validate_derivative(den.nodes)})")
+        end
+
+        def validate_derivative(den_nodes)
+          str = ""
+          if den_nodes.first.name == "mi"
+            node = den_nodes[1]
+            if %w[msub msup].include?(node.name)
+              case node.nodes.first.name
+              when "mi"
+                str += Utility.html_entity_to_unicode(node.nodes.first.nodes.first)
+              when "mrow"
+                node.nodes.first.nodes.each do |element|
+                  break unless element.name == "mi"
+
+                  str += Utility.html_entity_to_unicode(element.nodes.first)
+                end
+              end
+            end
+          end
+          str
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module Plurimath
           "\\hat#{first_value}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           mo_tag = (Utility.ox_element("mo") << "^")
           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/inf.rb

@@ -18,22 +18,25 @@ module Plurimath
           "\\#{class_name}#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           first_value = Utility.ox_element("mo") << class_name
           return first_value unless all_values_exist?
 
-          value_array = [first_value]
-          value_array << parameter_one&.to_mathml_without_math_tag
-          value_array << parameter_two&.to_mathml_without_math_tag
           tag_name = if parameter_two && parameter_one
                        "underover"
                      else
                        parameter_one ? "under" : "over"
                      end
+          inf_tag = ox_element("m#{tag_name}")
           Utility.update_nodes(
-            Utility.ox_element("m#{tag_name}"),
-            value_array,
+            inf_tag,
+            [
+              first_value,
+              parameter_one&.to_mathml_without_math_tag(intent),
+              parameter_two&.to_mathml_without_math_tag(intent),
+            ],
           )
+          intentify(inf_tag, intent, func_name: :function, intent_name: :function)
         end
 
         def to_omml_without_math_tag(display_style)

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

@@ -38,7 +38,7 @@ module Plurimath
           "\\#{class_name}#{first_value}#{second_value} #{parameter_three&.to_latex}".strip
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           base_element = (Utility.ox_element("mo") << invert_unicode_symbols.to_s)
           return base_element unless all_values_exist?
 
@@ -47,19 +47,22 @@ module Plurimath
             msubsup_tag,
             [
               base_element,
-              validate_mathml_tag(parameter_one),
-              validate_mathml_tag(parameter_two),
+              validate_mathml_tag(parameter_one, intent),
+              validate_mathml_tag(parameter_two, intent),
             ],
           )
+          msubsup_tag = masked_tag(msubsup_tag) if options && options.key?(:mask)
           return msubsup_tag if parameter_three.nil?
 
+          mrow = ox_element("mrow")
           Utility.update_nodes(
-            Utility.ox_element("mrow"),
+            mrow,
             [
               msubsup_tag,
-              parameter_three&.to_mathml_without_math_tag,
+              wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent), intent),
             ].flatten.compact,
           )
+          intentify(mrow, intent, func_name: :naryand, intent_name: :integral)
         end
 
         def to_omml_without_math_tag(display_style)

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

@@ -6,9 +6,9 @@ module Plurimath
   module Math
     module Function
       class Intent < BinaryFunction
-        def to_mathml_without_math_tag
-          first_value = parameter_one.to_mathml_without_math_tag
-          first_value.attributes[:intent] = Utility.html_entity_to_unicode(parameter_two.value)
+        def to_mathml_without_math_tag(intent)
+          first_value = parameter_one.to_mathml_without_math_tag(intent)
+          first_value.attributes["intent"] = encoded_intent(first_value)
           first_value
         end
 
@@ -16,6 +16,43 @@ module Plurimath
           first_value = "(#{parameter_two.to_unicodemath}#{parameter_one.to_unicodemath})" if parameter_one || parameter_two
           "ⓘ#{first_value}"
         end
+
+        private
+
+        def encoded_intent(tag)
+          if parameter_two.value == ":derivative" && encodable?
+            field = parameter_one.value
+            unicode = encode(field[0].parameter_one.value)
+            unfenced_str = fence_value(tag.nodes[1].nodes[1..-2]) if tag.nodes[1]["intent"] == ":fenced"
+            fenced_str = "(#{unfenced_str})" unless unfenced_str.empty?
+            ":derivative(1,#{unicode}#{fenced_str},#{unfenced_str})"
+          else
+            Utility.html_entity_to_unicode(parameter_two.value)
+          end
+        end
+
+        def encodable?
+          return unless parameter_one.is_a?(Formula)
+
+          field = parameter_one.value[0]
+          field.is_a?(Power) &&
+            prime_unicode?(field.parameter_two) &&
+            field.parameter_one.is_a?(Symbols::Symbol)
+        end
+
+        def fence_value(nodes)
+          str = ""
+          nodes.each do |node|
+            break unless node.name == "mi"
+
+            str += encode(node.nodes.first)
+          end
+          str
+        end
+
+        def encode(str)
+          Utility.html_entity_to_unicode(str)
+        end
       end
     end
   end

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

@@ -10,7 +10,7 @@ module Plurimath
           "left#{parameter_one}"
         end
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           mo = Utility.ox_element("mo")
           mo << left_paren if parameter_one
           mo
@@ -59,6 +59,10 @@ module Plurimath
           "#{spacing}\"#{dump_ox_nodes(t_tag).gsub(/\s+/, "")}\" left\n"
         end
 
+        def to_unicodemath_math_zone(spacing = "", _, _)
+          "#{spacing}\"#{parameter_one}\" left\n"
+        end
+        
         protected
 
         def left_paren

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

@@ -24,25 +24,25 @@ module Plurimath
           "\\#{class_name}#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag
-          first_value = (Utility.ox_element("mo") << "lim")
-          if parameter_one || parameter_two
-            value_array = [first_value]
-            value_array << parameter_one&.to_mathml_without_math_tag
-            value_array << parameter_two&.to_mathml_without_math_tag
-            tag_name = if parameter_two && parameter_one
-                         "underover"
-                       else
-                         parameter_one ? "under" : "over"
-                       end
-            munderover_tag = Utility.ox_element("m#{tag_name}")
-            Utility.update_nodes(
-              munderover_tag,
-              value_array,
-            )
-          else
-            first_value
-          end
+        def to_mathml_without_math_tag(intent)
+          first_value = Utility.ox_element("mo") << "lim"
+          return first_value unless all_values_exist?
+
+          tag_name = if parameter_two && parameter_one
+                       "underover"
+                     else
+                       parameter_one ? "under" : "over"
+                     end
+          lim_tag = Utility.ox_element("m#{tag_name}")
+          Utility.update_nodes(
+            lim_tag,
+            [
+              first_value,
+              parameter_one&.to_mathml_without_math_tag(intent),
+              parameter_two&.to_mathml_without_math_tag(intent),
+            ],
+          )
+          intentify(lim_tag, intent, func_name: :function, intent_name: :function)
         end
 
         def to_omml_without_math_tag(display_style)

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

@@ -13,12 +13,12 @@ module Plurimath
           third_value: "supscript",
         }.freeze
 
-        def to_mathml_without_math_tag
+        def to_mathml_without_math_tag(intent)
           underover = Utility.ox_element("munderover")
           value_array = [
-            validate_mathml_fields(parameter_one),
-            validate_mathml_fields(parameter_two),
-            validate_mathml_fields(parameter_three),
+            validate_mathml_fields(parameter_one, intent),
+            validate_mathml_fields(parameter_two, intent),
+            validate_mathml_fields(parameter_three, intent),
           ]
           Utility.update_nodes(underover, value_array)
         end