plurimath 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18df410d2655f777a8bf6379ec49334cc4d595e73b100e61287e5c385674a7b3
-  data.tar.gz: ae5bcfd6527302f5811b80ab02d61c4f25027c9526720402467736d2d4ccdf10
+  metadata.gz: 10711816eed513eb42250bdc90628a5ed3c9847cb33546e7df19ea29ca56b85e
+  data.tar.gz: 872e488b9b856e55c6e00ac6c19e089853950ec8a58fb4057abe601efee88604
 SHA512:
-  metadata.gz: 671778813a9f27fc1911226f587c93ee156591abf54acba8f922dc620caa8fd13019c72ce40695a659ba8455745ddd007a19d6fc1444cafd1744946d97ae7f1d
-  data.tar.gz: 522d01abb0c1d7482fd3d1ff598891007540559f8031d9ad0f53379d9eac577c89e666f827225325df4a10c8ea504479fbb523c11e171cbd7cbc2b96000afaa1
+  metadata.gz: b916d733033785acb282ffe2544e05387b65b54f53e83ba7f28cbb7e73ea71f8766129adb8d369560cb3b2df46de6f5215d68bb85755c3bb1b3d35e44963403e
+  data.tar.gz: 07204d723d30656e42791e79d954864da64acc41dbf84dff936e8fc88a51ca4a22d40b8fd426bd81f523a829837d5c0e8f7fcd5569a12025eb5128dc00cda0de

data/lib/plurimath/asciimath/constants.rb

@@ -310,13 +310,15 @@ module Plurimath
         tt
         ii
       ].freeze
-      SUB_SUP_CLASSES = %w[
+      TERNARY_CLASSES = %w[
         prod
+        sum
+        int
+      ].freeze
+      SUB_SUP_CLASSES = %w[
         oint
         lim
-        sum
         log
-        int
       ].freeze
       SPECIAL_BOLD_ALPHABETS = %w[
         ZZ

data/lib/plurimath/asciimath/parse.rb

@@ -8,7 +8,8 @@ module Plurimath
       rule(:base)   { str("_") }
       rule(:power)  { str("^") }
       rule(:space)  { match(/\s+/) }
-      rule(:comma)  { (str(",") >> space.maybe) }
+      rule(:comma)  { (str(",") >> space?) }
+      rule(:space?) { space.maybe }
       rule(:number) do
         (match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)).as(:number) |
           match("[0-9]").repeat(1).as(:number) |
@@ -21,6 +22,16 @@ module Plurimath
       rule(:color_left_parenthesis)  { str("(") | str("[") | str("{") }
       rule(:color_right_parenthesis) { str(")") | str("]") | str("}") }
 
+      rule(:ternary_classes_rules) do
+        (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> (ternary_classes >> power_base >> space? >> iteration.as(:third_value).maybe).as(:ternary) >> space? >> str("right") >> space? >> left_right_close_paren.as(:right)) |
+          (ternary_classes >> power_base >> space? >> iteration.as(:third_value).maybe).as(:ternary) |
+          ternary_classes
+      end
+
+      rule(:ternary_classes) do
+        arr_to_expression(Constants::TERNARY_CLASSES, :ternary_class)
+      end
+
       rule(:binary_classes) do
         arr_to_expression(Constants::BINARY_CLASSES, :binary_class)
       end
@@ -52,8 +63,8 @@ module Plurimath
       end
 
       rule(:left_right) do
-        (str("left") >> left_right_open_paren.as(:left) >> iteration.as(:left_right_value) >> str("right") >> left_right_close_paren.as(:right)) |
-          ((table.as(:numerator) >> space.maybe >> match(/(?<!\/)\/(?!\/)/) >> space.maybe >> iteration.as(:denominator)).as(:frac) >> expression) |
+        (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> (iteration.maybe >> sequence.maybe).as(:left_right_value) >> space? >> str("right") >> space? >> left_right_close_paren.as(:right)) |
+          ((table.as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac) >> expression) |
           (table.as(:table) >> expression.maybe)
       end
 
@@ -65,39 +76,40 @@ module Plurimath
       rule(:symbol_text_or_integer) do
         sub_sup_classes |
           binary_classes |
+          ternary_classes |
           hash_to_expression(Constants.precompile_constants) |
           (match(/[0-9]/).as(:number) >> comma.as(:comma)).repeat(1).as(:comma_separated) |
           quoted_text |
           (str("d").as(:d) >> str("x").as(:x)).as(:intermediate_exp) |
-          match["a-zA-Z"].as(:symbol) |
+          ((str("left").absent? >> str("right").absent?) >> match["a-zA-Z"].as(:symbol)) |
           match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?ℒℛᑕᑐ]/).as(:symbol) |
           number
       end
 
       rule(:power_base) do
-        (base >> space.maybe >> sequence.as(:base_value) >> power >> space.maybe >> sequence.as(:power_value)) |
-          (space.maybe >> base >> space.maybe >> sequence.as(:base_value)).as(:base) |
-          (space.maybe >> power >> space.maybe >> sequence.as(:power_value)).as(:power) |
-          (space.maybe >> base >> space.maybe >> power.as(:symbol).as(:base_value)).as(:base) |
-          (space.maybe >> power >> space.maybe >> base.as(:symbol).as(:power_value)).as(:power)
+        (base >> space? >> sequence.as(:base_value) >> power >> space? >> sequence.as(:power_value)) |
+          (space? >> base >> space? >> sequence.as(:base_value)).as(:base) |
+          (space? >> power >> space? >> sequence.as(:power_value)).as(:power) |
+          (space? >> base >> space? >> power.as(:symbol).as(:base_value)).as(:base) |
+          (space? >> power >> space? >> base.as(:symbol).as(:power_value)).as(:power)
       end
 
       rule(:power_base_rules) do
         (sub_sup_classes >> power_base).as(:power_base) |
-          (binary_classes >> space.maybe >> sequence.as(:base_value).maybe >> space.maybe >> sequence.as(:power_value).maybe).as(:power_base) |
+          (binary_classes >> space? >> sequence.as(:base_value).maybe >> space? >> sequence.as(:power_value).maybe).as(:power_base) |
           (sequence.as(:power_base) >> power_base).as(:power_base)
       end
 
       rule(:table) do
-        (str("{").as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
-          (open_table.as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
-          (str("norm").as(:norm) >> open_table.as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
-          (str("|").as(:table_left) >> space.maybe >> tr >> space.maybe >> str("|").as(:table_right)) |
-          (str("left") >> left_right_open_paren.as(:left) >> space.maybe >> tr >> space.maybe >> str("right") >> left_right_close_paren.as(:right))
+        (str("{").as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
+          (open_table.as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
+          (str("norm").as(:norm) >> open_table.as(:table_left) >> space? >> tr >> space? >> close_table.as(:table_right)) |
+          (str("|").as(:table_left) >> space? >> tr >> space? >> str("|").as(:table_right)) |
+          (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> tr >> space? >> str("right") >> space? >> left_right_close_paren.as(:right))
       end
 
       rule(:tr) do
-        ((left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row) >> comma >> space.maybe >> tr.as(:expr)) |
+        ((left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row) >> comma >> space? >> tr.as(:expr)) |
           (left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row)
       end
 
@@ -107,27 +119,28 @@ module Plurimath
       end
 
       rule(:sequence) do
-        (lparen.as(:lparen) >> space.maybe >> expression.maybe.as(:expr) >> space.maybe >> rparen.maybe.as(:rparen)).as(:intermediate_exp) |
+        (lparen.as(:lparen) >> space? >> expression.maybe.as(:expr) >> space? >> rparen.maybe.as(:rparen)).as(:intermediate_exp) |
           (str("text") >> lparen.capture(:paren) >> read_text.as(:text) >> rparen.maybe).as(:intermediate_exp) |
           symbol_text_or_integer
       end
 
       rule(:frac) do
-        (sequence.as(:numerator) >> space.maybe >> match(/(?<!\/)\/(?!\/)/) >> space.maybe >> iteration.as(:denominator)).as(:frac) |
+        (sequence.as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac) |
           ((power_base_rules | power_base).as(:numerator) >> match(/(?<!\/)\/(?!\/)/) >> iteration.as(:denominator)).as(:frac)
       end
 
       rule(:mod) do
-        (sequence.as(:dividend) >> space.maybe >> str("mod").as(:mod) >> space.maybe >> iteration.as(:divisor)).as(:mod) |
-          ((power_base_rules >> power_base).as(:dividend) >> space.maybe >> str("mod").as(:mod) >> space.maybe >> iteration.as(:divisor)).as(:mod) |
-          (power_base_rules.as(:dividend) >> space.maybe >> str("mod").as(:mod) >> space.maybe >> iteration.as(:divisor)).as(:mod)
+        (sequence.as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> iteration.as(:divisor)).as(:mod) |
+          ((power_base_rules >> power_base).as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> iteration.as(:divisor)).as(:mod) |
+          (power_base_rules.as(:dividend) >> space? >> str("mod").as(:mod) >> space? >> iteration.as(:divisor)).as(:mod)
       end
 
       rule(:iteration) do
-        table.as(:table) |
+        ternary_classes_rules |
+          table.as(:table) |
           comma.as(:comma) |
           mod |
-          (sequence.as(:sequence) >> space.maybe >> str("//").as(:symbol)) |
+          (sequence.as(:sequence) >> space? >> str("//").as(:symbol)) |
           (str("color") >> color_value.as(:color) >> sequence.as(:color_value)) |
           frac |
           (power_base_rules >> power_base) |
@@ -138,12 +151,12 @@ module Plurimath
 
       rule(:expression) do
         left_right.as(:left_right) |
-          (iteration >> space.maybe >> expression).as(:expr) |
+          (iteration >> space? >> expression).as(:expr) |
           (base.as(:symbol) >> expression.maybe).as(:expr) |
           (power.as(:symbol) >> expression.maybe).as(:expr) |
           str("") |
-          (rparen.as(:rparen) >> space.maybe >> controversial_symbols >> comma.as(:comma).maybe >> expression).repeat(1).as(:expr) |
-          (power.as(:symbol) >> space.maybe >> expression).as(:expr) |
+          (rparen.as(:rparen) >> space? >> controversial_symbols >> comma.as(:comma).maybe >> expression).repeat(1).as(:expr) |
+          (power.as(:symbol) >> space? >> expression).as(:expr) |
           comma.as(:comma).maybe
       end
 
@@ -176,8 +189,8 @@ module Plurimath
         first_value = str(expr.first.to_s)
         case expr.last
         when :symbol then first_value.as(:symbol)
-        when :unary_class then (first_value.as(:unary_class) >> space.maybe >> sequence.maybe).as(:unary)
-        when :fonts then first_value.as(:fonts_class) >> space.maybe >> sequence.as(:fonts_value)
+        when :unary_class then (first_value.as(:unary_class) >> space? >> sequence.maybe).as(:unary)
+        when :fonts then first_value.as(:fonts_class) >> space? >> sequence.as(:fonts_value)
         when :special_fonts then first_value.as(:bold_fonts)
         end
       end

data/lib/plurimath/asciimath/transform.rb

@@ -12,6 +12,7 @@ module Plurimath
       rule(rparen: simple(:rparen)) { Utility.symbol_object(rparen) }
       rule(number: simple(:number)) { Math::Number.new(number) }
 
+      rule(ternary: simple(:ternary))       { ternary }
       rule(sequence: simple(:sequence))     { sequence }
       rule(table_row: simple(:table_row))   { table_row }
       rule(sequence: sequence(:sequence))   { sequence }
@@ -41,6 +42,10 @@ module Plurimath
         Utility.get_class(binary).new
       end
 
+      rule(ternary_class: simple(:ternary)) do
+        Utility.get_class(ternary).new
+      end
+
       rule(comma_separated: subtree(:comma_separated)) do
         comma_separated.flatten
       end
@@ -127,6 +132,11 @@ module Plurimath
         new_arr
       end
 
+      rule(sequence: simple(:sequence),
+           number: simple(:number)) do
+        [sequence, Math::Number.new(number.to_s)]
+      end
+
       rule(table_row: simple(:table_row),
            expr: simple(:expr)) do
         new_arr = [table_row]
@@ -680,6 +690,82 @@ module Plurimath
         )
       end
 
+      rule(ternary_class: simple(:function),
+           base_value: simple(:base),
+           power_value: simple(:power)) do
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+          Utility.unfenced_value(power),
+        )
+      end
+
+      rule(ternary_class: simple(:function),
+           base: simple(:base)) do
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+        )
+      end
+
+      rule(ternary_class: simple(:function),
+           base: simple(:base),
+           third_value: simple(:third)) do
+        third_value = third.is_a?(Slice) ? nil : third
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+          nil,
+          third_value,
+        )
+      end
+
+      rule(ternary_class: simple(:function),
+           power: simple(:power)) do
+        Utility.get_class(function).new(
+          nil,
+          Utility.unfenced_value(power),
+        )
+      end
+
+      rule(ternary_class: simple(:function),
+           expr: simple(:expr)) do
+        [
+          Utility.get_class(function).new,
+          expr,
+        ]
+      end
+
+      rule(ternary_class: simple(:function),
+           expr: sequence(:expr)) do
+        expr.insert(0, Utility.get_class(function).new)
+      end
+
+      rule(ternary: simple(:ternary),
+           expr: simple(:expr)) do
+        [ternary, expr]
+      end
+
+      rule(ternary_class: simple(:function),
+           power: simple(:power),
+           third_value: simple(:third)) do
+        third_value = third.is_a?(Slice) ? nil : third
+        Utility.get_class(function).new(
+          nil,
+          Utility.unfenced_value(power),
+          third_value,
+        )
+      end
+
+      rule(ternary_class: simple(:function),
+           base_value: simple(:base),
+           power_value: simple(:power),
+           third_value: simple(:third)) do
+        third_value = third.is_a?(Slice) ? nil : third
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+          Utility.unfenced_value(power),
+          third_value,
+        )
+      end
+
       rule(unary_class: simple(:function),
            intermediate_exp: simple(:int_exp)) do
         first_value = if Utility::UNARY_CLASSES.include?(function)
@@ -722,6 +808,19 @@ module Plurimath
         ]
       end
 
+      rule(unary_class: simple(:function),
+           ternary_class: simple(:ternary_class)) do
+        [
+          Utility.get_class(function).new,
+          Utility.get_class(ternary_class).new,
+        ]
+      end
+
+      rule(ternary: simple(:ternary),
+           expr: sequence(:expr)) do
+        expr.insert(0, ternary)
+      end
+
       rule(unary_class: simple(:function),
            text: simple(:text)) do
         Utility.get_class(function).new(
@@ -761,6 +860,18 @@ module Plurimath
         )
       end
 
+      rule(left: simple(:left),
+           left_right_value: sequence(:left_right),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(left),
+            Math::Formula.new(left_right),
+            Math::Function::Right.new(right),
+          ],
+        )
+      end
+
       rule(dividend: simple(:dividend),
            mod: simple(:mod),
            divisor: simple(:divisor)) do

data/lib/plurimath/latex/constants.rb

@@ -3430,7 +3430,7 @@ module Plurimath
         mbfit: :fonts,
         msans: :fonts,
         tilde: :unary,
-        prod: :power_base,
+        prod: :ternary,
         zeta: :symbols,
         quad: :symbols,
         Vert: :symbols,
@@ -3563,7 +3563,7 @@ module Plurimath
         mbox: :unary,
         text: :text,
         '"': :symbols,
-        sum: :power_base,
+        sum: :ternary,
         inf: :power_base,
         lim: :power_base,
         log: :power_base,

data/lib/plurimath/latex/parse.rb

@@ -205,6 +205,9 @@ module Plurimath
           (slashed_value(first_value, :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
         when :text
           (slashed_value(first_value, :text) >> (str("{") >> match("[^}]").repeat.as(:first_value) >> str("}")))
+        when :ternary
+          (slashed_value(first_value, :ternary_functions) >> dynamic_power_base >> sequence.as(:third_value).maybe).as(:ternary_class) |
+            slashed_value(first_value, :ternary)
         end
       end
 

data/lib/plurimath/latex/transform.rb

@@ -17,8 +17,10 @@ module Plurimath
       rule("\\\\" => simple(:slash))  { Math::Symbol.new(slash) }
       rule(expression: simple(:expr)) { expr }
       rule(environment: simple(:env)) { env }
+      rule(ternary: simple(:ternary)) { Utility.get_class(ternary).new }
 
       rule(unary_functions: simple(:unary)) { unary }
+      rule(ternary_class: simple(:ternary)) { ternary }
       rule(left_right: simple(:left_right)) { left_right }
       rule(under_over: simple(:under_over)) { under_over }
       rule(power_base: simple(:power_base)) { power_base }
@@ -308,6 +310,11 @@ module Plurimath
         )
       end
 
+      rule(ternary_functions: simple(:ternary),
+           subscript: simple(:subscript)) do
+        Utility.get_class(ternary).new(subscript)
+      end
+
       rule(unary_functions: simple(:unary),
            supscript: simple(:supscript)) do
         unary_function = if unary.is_a?(Parslet::Slice)
@@ -321,6 +328,25 @@ module Plurimath
         )
       end
 
+      rule(ternary_functions: simple(:ternary),
+           subscript: simple(:subscript),
+           third_value: simple(:third_value)) do
+        Utility.get_class(ternary).new(
+          subscript,
+          nil,
+          third_value,
+        )
+      end
+
+      rule(ternary_functions: simple(:ternary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Utility.get_class(ternary).new(
+          subscript,
+          supscript,
+        )
+      end
+
       rule(unary_functions: simple(:unary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
@@ -336,6 +362,17 @@ module Plurimath
         )
       end
 
+      rule(ternary_functions: simple(:ternary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript),
+           third_value: simple(:third_value)) do
+        Utility.get_class(ternary).new(
+          subscript,
+          supscript,
+          third_value,
+        )
+      end
+
       rule(fonts: simple(:fonts),
            intermediate_exp: simple(:int_exp)) do
         if Utility::FONT_STYLES[fonts.to_sym]

data/lib/plurimath/math/core.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Core
+      def class_name
+        self.class.name.split("::").last.downcase
+      end
+
+      def insert_t_tag
+        Array(to_omml_without_math_tag)
+      end
+
+      def tag_name
+        "subsup"
+      end
+
+      def nary_attr_value
+        ""
+      end
+
+      def empty_tag(wrapper_tag)
+        r_tag = Utility.ox_element("r", namespace: "m")
+        r_tag << (Utility.ox_element("t", namespace: "m") << "&#8203;")
+        wrapper_tag << r_tag
+      end
+
+      def omml_parameter(field, tag_name: , namespace: "m")
+        tag = Utility.ox_element(tag_name, namespace: namespace)
+        return empty_tag(tag) unless field
+
+        Utility.update_nodes(
+          tag,
+          field&.insert_t_tag,
+        )
+      end
+
+      def validate_function_formula
+        true
+      end
+    end
+  end
+end

data/lib/plurimath/math/formula.rb

@@ -2,7 +2,7 @@
 
 module Plurimath
   module Math
-    class Formula
+    class Formula < Core
       attr_accessor :value, :left_right_wrapper
 
       def initialize(value = [], left_right_wrapper = true)
@@ -85,49 +85,57 @@ module Plurimath
         )
         math_element = Utility.ox_element("oMath", namespace: "m")
         Utility.update_nodes(math_element, omml_content)
-        para_element << math_element
-        Ox.dump(para_element, indent: 2).gsub("&amp;", "&")
+        Utility.update_nodes(para_element, Array(math_element))
+        Ox.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
       end
 
       def omml_content
-        value.map do |object|
-          if object.is_a?(Symbol)
-            mt = Utility.ox_element("t", namespace: "m")
-            mt << object.value
-          else
-            object.to_omml_without_math_tag
-          end
-        end
+        value&.map(&:insert_t_tag)
       end
 
       def to_omml_without_math_tag
-        if value.length == 2 && ["underover", "powerbase"].include?(
-          value&.first&.class_name,
-        )
-          nary_tag
-        else
-          r_element = Utility.ox_element("r", namespace: "m")
-          r_element << Utility.rpr_element if ["symbol", "number", "text"].include?(value&.first&.class_name)
-          Utility.update_nodes(r_element, omml_content)
-        end
+        return nary_tag if nary_tag_able?
+
+        omml_content
       end
 
       def nary_tag
         nary_tag = Utility.ox_element("nary", namespace: "m")
         e_tag    = Utility.ox_element("e", namespace: "m")
-        e_tag   << value&.last&.to_omml_without_math_tag
+        Utility.update_nodes(e_tag, value.last.insert_t_tag)
         Utility.update_nodes(
           nary_tag,
-          [
-            value.first.omml_nary_tag,
-            e_tag,
-          ].flatten.compact,
+          (value.first.omml_nary_tag << e_tag),
         )
+        [nary_tag]
       end
 
       def class_name
         self.class.name.split("::").last.downcase
       end
+
+      def extract_class_from_text
+        return false unless (value.length < 2 && value&.first&.is_a?(Function::Text))
+
+        value.first.parameter_one
+      end
+
+      def nary_attr_value
+        value.first.nary_attr_value
+      end
+
+      def nary_tag_able?
+        value.length == 2 &&
+          ["underover", "powerbase"].include?(value&.first&.class_name) &&
+          (
+            value&.first&.parameter_one&.to_omml_without_math_tag&.length == 1 ||
+            value&.first&.parameter_one.to_omml_without_math_tag.match?(/^&#x\w*\d*;$/)
+          )
+      end
+
+      def validate_function_formula
+        (value.none?(Function::Left) || value.none?(Function::Right))
+      end
     end
   end
 end

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

@@ -14,6 +14,25 @@ module Plurimath
             first_value << symbol,
           )
         end
+
+        def to_omml_without_math_tag
+          md = (Utility.ox_element("d", namespace: "m") << mdpr_tag)
+          me = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(me, omml_value)
+          Utility.update_nodes(md, Array(me))
+          [md]
+        end
+
+        protected
+
+        def mdpr_tag
+          attribute = { "m:val": "|" }
+          mdpr = Utility.pr_element("d", namespace: "m")
+          mdpr << Utility.ox_element("begChr", namespace: "m", attributes: attribute)
+          mdpr << Utility.ox_element("endChr", namespace: "m", attributes: attribute)
+          mdpr << Utility.ox_element("sepChr", namespace: "m", attributes: { "m:val": "" })
+          mdpr << Utility.ox_element("grow", namespace: "m")
+        end
       end
     end
   end

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

@@ -6,6 +6,9 @@ module Plurimath
   module Math
     module Function
       class Arccos < UnaryFunction
+        def validate_function_formula
+          false
+        end
       end
     end
   end

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

@@ -6,6 +6,9 @@ module Plurimath
   module Math
     module Function
       class Arcsin < UnaryFunction
+        def validate_function_formula
+          false
+        end
       end
     end
   end

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

@@ -6,6 +6,9 @@ module Plurimath
   module Math
     module Function
       class Arctan < UnaryFunction
+        def validate_function_formula
+          false
+        end
       end
     end
   end

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

@@ -25,7 +25,7 @@ module Plurimath
         def to_omml_without_math_tag
           bar = Utility.ox_element("bar", namespace: "m")
           me  = Utility.ox_element("e", namespace: "m")
-          me << parameter_one.to_omml_without_math_tag if parameter_one
+          Utility.update_nodes(me, omml_value) if parameter_one
           Utility.update_nodes(
             bar,
             [
@@ -33,6 +33,7 @@ module Plurimath
               me,
             ],
           )
+          [bar]
         end
 
         protected

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

@@ -37,18 +37,16 @@ module Plurimath
         def to_omml_without_math_tag
           ssub_element  = Utility.ox_element("sSub", namespace: "m")
           subpr_element = Utility.ox_element("sSubPr", namespace: "m")
-          e_element     = Utility.ox_element("e", namespace: "m")
-          sub_element   = Utility.ox_element("sub", namespace: "m")
-          sub_element << parameter_two.to_omml_without_math_tag if parameter_two
+          subpr_element << Utility.pr_element("ctrl", true, namespace: "m")
           Utility.update_nodes(
             ssub_element,
             [
-              subpr_element << Utility.pr_element("ctrl", true, namespace: "m"),
-              e_element << parameter_one.to_omml_without_math_tag,
-              sub_element,
+              subpr_element,
+              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_two, tag_name: "sub"),
             ],
           )
-          ssub_element
+          [ssub_element]
         end
       end
     end