plurimath 0.3.8 → 0.4.1

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

@@ -1,19 +1,37 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Tilde < UnaryFunction
+      class Tilde < BinaryFunction
         def to_mathml_without_math_tag
           mover = Utility.ox_element("mover")
+          mover.attributes.merge!({ accent: parameter_two[:accent]}) if parameter_two
           first_value = (Utility.ox_element("mo") << "~")
           second_value = parameter_one.to_mathml_without_math_tag if parameter_one
           Utility.update_nodes(mover, [second_value, first_value])
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element("~", rpr_tag: false) unless all_values_exist?
+
+          if parameter_two && parameter_two[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new("~")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
+        end
+
+        def validate_function_formula
+          false
+        end
+
+        protected
+
+        def acc_tag(display_style)
           acc_tag    = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
           acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "˜" }))
@@ -21,7 +39,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [acc_tag]

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

@@ -31,8 +31,8 @@ module Plurimath
           "<tr>#{first_value}</tr>"
         end
 
-        def to_omml_without_math_tag
-          omml_content = parameter_one&.map(&:to_omml_without_math_tag)
+        def to_omml_without_math_tag(display_style)
+          omml_content = parameter_one&.map { |obj| obj.to_omml_without_math_tag(display_style) }
           if parameter_one.count.eql?(1)
             omml_content
           else

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

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Ubrace < UnaryFunction
+      class Ubrace < BinaryFunction
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "ubrace#{first_value}"
+        end
+
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\underbrace#{first_value}"
@@ -13,37 +18,36 @@ module Plurimath
 
         def to_mathml_without_math_tag
           mo_tag = (Utility.ox_element("mo") << "&#x23df;")
-          if parameter_one
-            over_tag = Utility.ox_element("munder")
-            arr_value = mathml_value
-            Utility.update_nodes(over_tag, (arr_value << mo_tag))
-          else
-            mo_tag
-          end
+          return mo_tag unless parameter_one
+
+          over_tag = Utility.ox_element("munder")
+          over_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
+          Utility.update_nodes(
+            over_tag,
+            [
+              parameter_one.to_mathml_without_math_tag,
+              mo_tag,
+            ],
+          )
         end
 
         def tag_name
           "underover"
         end
 
+        def omml_tag_name
+          "undOvr"
+        end
+
         def validate_function_formula
           false
         end
 
-        def to_omml_without_math_tag
-          limlow   = Utility.ox_element("limLow", namespace: "m")
-          limlowpr = Utility.ox_element("limLowPr", namespace: "m")
-          limlowpr << Utility.pr_element("ctrl", true, namespace: "m")
-          lim = Utility.ox_element("lim", namespace: "m")
-          Utility.update_nodes(
-            limlow,
-            [
-              limlowpr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              Utility.update_nodes(lim, r_element("⏟")),
-            ],
-          )
-          [limlow]
+        def to_omml_without_math_tag(display_style)
+          return r_element("⏟", rpr_tag: false) unless all_values_exist?
+
+          symbol = Symbol.new("⏟")
+          Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
       end
 

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

@@ -1,41 +1,71 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Ul < UnaryFunction
+      class Ul < BinaryFunction
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "underline#{first_value}"
+        end
+
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          "\\underline#{first_value}"
+        end
+
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
+          mo_tag = Utility.ox_element("mo") << "&#x332;"
+          return mo_tag unless parameter_one
+
+          munder_tag = Utility.ox_element("munder")
+          munder_tag.attributes.merge!(parameter_two) if parameter_two && !parameter_two.empty?
           Utility.update_nodes(
-            Utility.ox_element("munder"),
+            munder_tag,
             [
-              first_value,
-              Utility.ox_element("mo") << "&#xaf;",
+              parameter_one&.to_mathml_without_math_tag,
+              mo_tag,
             ],
           )
         end
 
-        def to_omml_without_math_tag
-          bar    = Utility.ox_element("bar", namespace: "m")
-          barpr  = Utility.ox_element("barPr", namespace: "m")
-          barpr << Utility.pr_element("ctrl", true, namespace: "m")
-          me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value)
-          Utility.update_nodes(
-            bar,
-            [
-              barpr,
-              me,
-            ],
-          )
-          [bar]
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#x332;", rpr_tag: false) unless all_values_exist?
+
+          if parameter_two && parameter_two[:accentunder]
+            groupchr_tag(display_style)
+          else
+            symbol = Symbol.new("&#x332;")
+            Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
         end
 
         def class_name
           "underline"
         end
+
+        def swap_class
+          Bar.new(parameter_one, parameter_two)
+        end
+
+        protected
+
+        def groupchr_tag(display_style)
+          groupchr = Utility.ox_element("groupChr", namespace: "m")
+          groupchrpr = Utility.ox_element("groupChrPR", namespace: "m")
+          chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "_" })
+          pos = Utility.ox_element("pos", namespace: "m", attributes: { "m:val": "bot" })
+          Utility.update_nodes(groupchrpr, [chr, pos])
+          Utility.update_nodes(
+            groupchr,
+            [
+              groupchrpr,
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
+            ],
+          )
+        end
       end
 
       Underline = Ul

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

@@ -52,7 +52,9 @@ module Plurimath
           "<i>#{class_name}</i>#{first_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element(class_name, rpr_tag: false) unless parameter_one
+
           func   = Utility.ox_element("func", namespace: "m")
           funcpr = Utility.ox_element("funcPr", namespace: "m")
           funcpr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -62,7 +64,7 @@ module Plurimath
           mt  = Utility.ox_element("t", namespace: "m") << class_name
           fname << Utility.update_nodes(mr, [rpr, mt])
           me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value) if parameter_one
+          Utility.update_nodes(me, omml_value(display_style)) if parameter_one
           Utility.update_nodes(
             func,
             [
@@ -104,12 +106,12 @@ module Plurimath
           parameter_one&.to_latex
         end
 
-        def omml_value
+        def omml_value(display_style)
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map(&:insert_t_tag)
+            return parameter_one&.compact&.map { |obj| obj.insert_t_tag(display_style) }
           end
 
-          Array(parameter_one&.insert_t_tag)
+          Array(parameter_one&.insert_t_tag(display_style))
         end
       end
     end

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

@@ -35,19 +35,21 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
-          overset = Overset.new(parameter_one, parameter_three)
-          return overset unless parameter_two
+        def to_omml_without_math_tag(display_style)
+          if !display_style
+            power_base = PowerBase.new(parameter_one, parameter_two, parameter_three)
+            return power_base.to_omml_without_math_tag(display_style)
+          end
 
-          Underset.new(overset, parameter_two)&.to_omml_without_math_tag
+          underover(display_style)
         end
 
-        def omml_nary_tag
+        def omml_nary_tag(display_style)
           pr = Utility.ox_element("naryPr", namespace: "m")
           [
             pr_element_value(pr),
-            omml_parameter(parameter_two, tag_name: "sub"),
-            omml_parameter(parameter_three, tag_name: "sup"),
+            omml_parameter(parameter_two, display_style, tag_name: "sub"),
+            omml_parameter(parameter_three, display_style, tag_name: "sup"),
           ]
         end
 
@@ -86,7 +88,7 @@ module Plurimath
         end
 
         def first_value(pr_element)
-          first_value = parameter_one.is_a?(Number) ? parameter_one.value : parameter_one.to_omml_without_math_tag
+          first_value = parameter_one.nary_attr_value
           first_value = Utility.html_entity_to_unicode(first_value)
           unless first_value == "∫"
             pr_element << Utility.ox_element(

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

@@ -18,7 +18,12 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          if !display_style
+            base = Base.new(parameter_one, parameter_two)
+            return base.to_omml_without_math_tag(display_style)
+          end
+
           limlow   = Utility.ox_element("limLow", namespace: "m")
           limlowpr = Utility.ox_element("limLowPr", namespace: "m")
           limlowpr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -26,8 +31,8 @@ module Plurimath
             limlow,
             [
               limlowpr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "lim"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "lim"),
             ],
           )
           [limlow]

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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Vec < UnaryFunction
+      class Vec < BinaryFunction
         def to_mathml_without_math_tag
+          mover = Utility.ox_element("mover")
           first_value = parameter_one&.to_mathml_without_math_tag
+          mover.attributes.merge!({ accent: parameter_two[:accent] }) if parameter_two
           Utility.update_nodes(
-            Utility.ox_element("mover"),
+            mover,
             [
               first_value,
               Utility.ox_element("mo") << "&#x2192;",
@@ -17,7 +19,20 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#x2192;", rpr_tag: false) unless all_values_exist?
+
+          if parameter_two && parameter_two[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new("→")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
+        end
+
+        protected
+
+        def acc_tag(display_style)
           acc_tag    = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
           acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "→" }))
@@ -25,7 +40,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [acc_tag]

data/lib/plurimath/math/number.rb

@@ -29,16 +29,20 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag
+      def to_omml_without_math_tag(_display_style)
         [(Utility.ox_element("t", namespace: "m") << value)]
       end
 
-      def insert_t_tag
+      def insert_t_tag(_display_style)
         r_tag = Utility.ox_element("r", namespace: "m")
         r_tag << (Utility.ox_element("t", namespace: "m") << value)
         [r_tag]
       end
 
+      def font_style_t_tag(_display_style)
+        Utility.ox_element("t", namespace: "m") << value
+      end
+
       def nary_attr_value
         value
       end

data/lib/plurimath/math/symbol.rb

@@ -58,11 +58,11 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag
+      def to_omml_without_math_tag(_display_style)
         value
       end
 
-      def insert_t_tag
+      def insert_t_tag(_display_style)
         r_tag = Utility.ox_element("r", namespace: "m")
         r_tag << (Utility.ox_element("t", namespace: "m") << value)
         [r_tag]
@@ -72,6 +72,18 @@ module Plurimath
         ["&#x22c0;", "&#x22c1;", "&#x22c2;", "&#x22c3;"].include?(value) ? "underover" : "subsup"
       end
 
+      def omml_tag_name
+        if ["&#x22c0;", "&#x22c1;", "&#x22c2;", "&#x22c3;", "&#x22c3;", "&#x2211;", "&#x220f;"].include?(value)
+          return "undOvr"
+        end
+
+        "subSup"
+      end
+
+      def font_style_t_tag(_display_style)
+        Utility.ox_element("t", namespace: "m") << value
+      end
+
       def nary_attr_value
         value
       end

data/lib/plurimath/math.rb

@@ -20,6 +20,7 @@ require_relative "html/parser"
 require_relative "omml/parser"
 require_relative "utility"
 require "ox"
+require "yaml"
 Ox.default_options = { encoding: "UTF-8" }
 
 module Plurimath
@@ -42,7 +43,9 @@ module Plurimath
 
       begin
         klass = klass_from_type(type)
-        klass.new(text).to_formula
+        formula = klass.new(text).to_formula
+        formula.input_string = text
+        formula
       rescue => ee
         parse_error!(text, type.to_sym)
       end

data/lib/plurimath/mathml/constants.rb

@@ -130,7 +130,6 @@ module Plurimath
         "⇒": "rArr",
         "⇐": "lArr",
         "⇔": "hArr",
-        "→": "->",
         "↣": ">->",
         "↠": "->>",
         "⤖": ">->>",
@@ -139,10 +138,19 @@ module Plurimath
         "−": "-",
         "⏞": "obrace",
         "⏟": "ubrace",
+        "→": "vec",
+        "̂": "hat",
+        "̲": "ul",
+        "¯": "bar",
         "&": "&",
         ">": ">",
         "&#x3c;": "<",
         "&amp;": "&",
+        "~": "tilde",
+        "..": "ddot",
+        "^": "hat",
+        "¯": "bar",
+        "_": "ul",
       }.freeze
       SYMBOLS = {
         "|": "|",

data/lib/plurimath/mathml/parser.rb

@@ -10,8 +10,10 @@ module Plurimath
       SUPPORTED_ATTRIBUTES = %w[
         columnlines
         mathvariant
+        accentunder
         mathcolor
         notation
+        accent
         close
         open
       ].freeze
@@ -22,11 +24,11 @@ module Plurimath
 
       def parse
         ox_nodes = Ox.load(text, strip_namespace: true)
-        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first
+        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first || true
         nodes = parse_nodes(ox_nodes.nodes)
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
-          displaystyle: display_style
+          display_style: display_style,
         )
       end
 

data/lib/plurimath/mathml/transform.rb

@@ -135,23 +135,33 @@ module Plurimath
         )
       end
 
-      rule(msubsup: sequence(:msubsup)) do
-        Math::Function::PowerBase.new(
-          msubsup[0],
-          msubsup[1],
-          msubsup[2],
-        )
+      rule(msubsup: sequence(:function)) do
+        base_class = function[0].is_a?(Math::Formula) ? function[0]&.value&.first : function[0]
+        if base_class.is_a?(Math::Function::BinaryFunction)
+          base_class.parameter_one = function[1]
+          base_class.parameter_two = function[2]
+          base_class
+        elsif base_class.is_a?(Math::Function::TernaryFunction)
+          base_class.parameter_one = function[1]
+          base_class.parameter_two = function[2]
+          base_class.parameter_three = function[3]
+          base_class
+        else
+          Math::Function::PowerBase.new(
+            function[0],
+            function[1],
+            function[2],
+          )
+        end
       end
 
       rule(munderover: sequence(:function)) do
-        binary_function = Plurimath::Math::Function::BinaryFunction
-        ternary_function = Plurimath::Math::Function::TernaryFunction
-        base_class = function[0]&.value&.first if function[0].is_a?(Math::Formula)
-        if base_class&.class&.ancestors&.include?(binary_function)
+        base_class = function[0].is_a?(Math::Formula) ? function[0]&.value&.first : function[0]
+        if base_class.is_a?(Math::Function::BinaryFunction)
           base_class.parameter_one = function[1]
           base_class.parameter_two = function[2]
           base_class
-        elsif base_class&.class&.ancestors&.include?(ternary_function)
+        elsif base_class.is_a?(Math::Function::TernaryFunction)
           base_class.parameter_one = function[1]
           base_class.parameter_two = function[2]
           base_class.parameter_three = function[3]
@@ -166,12 +176,15 @@ module Plurimath
       end
 
       rule(mrow: subtree(:mrow)) do
-        if mrow.any?(String)
-          mrow.each_with_index do |object, ind|
-            mrow[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
-          end
+        flatten_mrow = Utility.populate_function_classes(mrow)
+        if flatten_mrow.length == 1
+          flatten_mrow.first
+        else
+          Math::Formula.new(
+            flatten_mrow,
+            Utility.mrow_left_right(flatten_mrow),
+          )
         end
-        Math::Formula.new(mrow.flatten.compact)
       end
 
       rule(msrow: sequence(:msrow)) do
@@ -184,8 +197,15 @@ module Plurimath
         )
       end
 
-      rule(mover: sequence(:mover)) do
-        if ["ubrace", "obrace"].any?(mover.last.class_name)
+      rule(mover: subtree(:mover)) do
+        Utility.binary_function_classes(mover, under: true)
+        if mover&.length == 1
+          if mover.first.class_name == "underline"
+            mover.first.swap_class
+          else
+            mover.first
+          end
+        elsif Constants::CLASSES.any?(mover&.last&.class_name)
           mover.last.parameter_one = mover.shift if mover.length > 1
           mover.last
         else
@@ -202,9 +222,16 @@ module Plurimath
             munder[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
           end
         end
+        Utility.binary_function_classes(munder, under: true)
         if ["ubrace", "obrace"].any?(munder.last.class_name)
           munder.last.parameter_one = munder.shift if munder.length > 1
           munder.last
+        elsif munder.length == 1
+          if munder.first.class_name == "bar"
+            munder.first.swap_class
+          else
+            munder.last
+          end
         else
           Math::Function::Underset.new(
             munder[1],
@@ -308,10 +335,12 @@ module Plurimath
 
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
-        Utility.join_attr_value(
-          attrs.is_a?(Hash) ? nil : attrs,
-          value&.flatten&.compact,
-        )
+        approved_attrs = if attrs.is_a?(Hash)
+          attrs.keys.any? { |k| ["accentunder", "accent"].include?(k.to_s) } ? attrs : nil
+        else
+          attrs
+        end
+        Utility.join_attr_value(approved_attrs, value&.flatten&.compact)
       end
     end
   end