plurimath 0.5.0 → 0.7.0

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

@@ -16,7 +16,7 @@ module Plurimath
           mo
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(_)
           mr = Utility.ox_element("m:r")
           if parameter_one
             mt = Utility.ox_element("m:t")
@@ -30,13 +30,31 @@ module Plurimath
         end
 
         def to_latex
-          "\\right #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || '.'}"
+          "\\right #{latex_paren}"
         end
 
         def validate_function_formula
           false
         end
 
+        def to_asciimath_math_zone(spacing = "", _, _)
+          "#{spacing}\"#{latex_paren}\" right\n"
+        end
+
+        def to_latex_math_zone(spacing = "", _, _)
+          "#{spacing}\"#{latex_paren}\" right\n"
+        end
+
+        def to_mathml_math_zone(spacing = "", _, _)
+          mo_tag = (Utility.ox_element("mo") << right_paren)
+          "#{spacing}\"#{dump_ox_nodes(mo_tag).gsub(/\s+/, "")}\" right\n"
+        end
+
+        def to_omml_math_zone(spacing = "", _, _, display_style:)
+          t_tag = (Utility.ox_element("t", namespace: "m") << right_paren)
+          "#{spacing}\"#{dump_ox_nodes(t_tag).gsub(/\s+/, "")}\" right\n"
+        end
+
         protected
 
         def right_paren

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Root < BinaryFunction
+        FUNCTION = {
+          name: "root",
+          first_value: "radicand",
+          second_value: "index",
+        }.freeze
+
         def to_mathml_without_math_tag
           first_value = parameter_one&.to_mathml_without_math_tag
           second_value = parameter_two&.to_mathml_without_math_tag

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

@@ -5,6 +5,13 @@ module Plurimath
   module Math
     module Function
       class Rule < TernaryFunction
+        FUNCTION = {
+          name: "rule",
+          first_value: "first argument",
+          second_value: "second argument",
+          third_value: "third argument",
+        }.freeze
+
         def to_asciimath
           ""
         end
@@ -20,7 +27,7 @@ module Plurimath
           Utility.ox_element("mi")
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(_)
           [Utility.ox_element("m:r") << Utility.ox_element("m:t")]
         end
 

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

@@ -6,6 +6,20 @@ module Plurimath
   module Math
     module Function
       class Scarries < UnaryFunction
+        def to_asciimath
+          asciimath_value
+        end
+
+        def to_latex
+          latex_value
+        end
+
+        def to_mathml_without_math_tag
+          scarries_tag = Utility.ox_element("mscarries")
+          Utility.update_nodes(scarries_tag, mathml_value)
+          scarries_tag
+        end
+
         def to_omml_without_math_tag(display_style)
           omml_value(display_style)
         end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Semantics < BinaryFunction
+        FUNCTION = {
+          name: "semantics",
+          first_value: "first argument",
+          second_value: "second argument",
+        }.freeze
+
         def to_mathml_without_math_tag
           first_value = parameter_one&.to_mathml_without_math_tag
           second_value = other_tags(parameter_two)
@@ -27,6 +33,15 @@ module Plurimath
           Array(parameter_one.insert_t_tag(display_style))
         end
 
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            semantics = self.class.new(Utility.filter_values(obj.value), self.parameter_two)
+            self.parameter_two = nil
+            obj.update(semantics)
+          end
+        end
+
         protected
 
         def other_tags(array)

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

@@ -33,6 +33,11 @@ module Plurimath
           )
           [rad_element]
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Stackrel < BinaryFunction
+        FUNCTION = {
+          name: "stackrel",
+          first_value: "above",
+          second_value: "below",
+        }.freeze
+
         def to_asciimath
           first_value  = wrapped(parameter_one)
           second_value = wrapped(parameter_two)
@@ -42,6 +48,14 @@ module Plurimath
           [limupp]
         end
 
+        def line_breaking(obj)
+          parameter_one.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(Utility.filter_values(obj.value), parameter_two))
+            self.parameter_two = nil
+          end
+        end
+
         protected
 
         def wrapped(field)

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

@@ -1,67 +1,34 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Substack < BinaryFunction
-        def to_latex
-          first_value  = parameter_one.to_latex if parameter_one
-          second_value = "\\\\#{parameter_two.to_latex}" if parameter_two
-          "\\#{class_name}{#{first_value}#{second_value}}"
+      class Substack < UnaryFunction
+        FUNCTION = {
+          name: "substack",
+          first_value: "above",
+          second_value: "below",
+        }.freeze
+
+        def to_asciimath
+          "{:#{parameter_one.compact.map(&:to_asciimath).join(",")}:}"
         end
 
-        def to_mathml_without_math_tag
-          value_array = []
-          value_array << parameter_one.to_mathml_without_math_tag if parameter_one
-          value_array << parameter_two.to_mathml_without_math_tag if parameter_two
-          Utility.update_nodes(Utility.ox_element("mtable"), value_array)
+        def to_latex
+          "\\#{class_name}{#{parameter_one&.compact&.map(&:to_latex)&.join(" \\\\ ")}}"
         end
 
-        def to_omml_without_math_tag(display_style)
-          Array(
-            Utility.update_nodes(
-              mm_element,
-              [
-                omml_parameter(parameter_one, display_style, tag_name: "mr"),
-                omml_parameter(parameter_two, display_style, tag_name: "mr"),
-              ],
-            ),
+        def to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("mtable"),
+            mathml_value,
           )
         end
 
-        protected
-
-        def mm_element
-          mcjc = Utility.ox_element(
-            "mcJc",
-            namespace: "m",
-            attributes: { "m:val": "center" },
-          )
-          mcount = Utility.ox_element(
-            "count",
-            namespace: "m",
-            attributes: { "m:val": "1" },
-          )
-          mbasejc = Utility.ox_element(
-            "baseJc",
-            namespace: "m",
-            attributes: { "m:val": "center", },
-          )
-          mplchide = Utility.ox_element(
-            "plcHide",
-            namespace: "m",
-            attributes: { "m:val": "1" },
-          )
-          mm   = Utility.ox_element("m", namespace: "m")
-          mc   = Utility.ox_element("mc", namespace: "m")
-          mpr  = Utility.ox_element("mpr", namespace: "m")
-          mcs  = Utility.ox_element("mcs", namespace: "m")
-          mcpr = Utility.ox_element("mcPr", namespace: "m")
-          mc << Utility.update_nodes(mcpr, [mcjc, mcount])
-          mcs << mc
-          Utility.update_nodes(mm, [mpr])
+        def to_omml_without_math_tag(display_style)
+          Table.new(parameter_one).to_omml_without_math_tag(display_style)
         end
       end
     end

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

@@ -6,6 +6,13 @@ module Plurimath
   module Math
     module Function
       class Sum < TernaryFunction
+        FUNCTION = {
+          name: "summation",
+          first_value: "subscript",
+          second_value: "supscript",
+          third_value: "term",
+        }.freeze
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -19,29 +26,29 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          first_value = ox_element("mo")
+          first_value << invert_unicode_symbols.to_s unless hide_function_name
+
           if parameter_one || parameter_two
-            value_array = []
-            value_array << parameter_one&.to_mathml_without_math_tag
-            value_array << parameter_two&.to_mathml_without_math_tag
+            value_array = [
+              parameter_one&.to_mathml_without_math_tag,
+              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.insert(0, first_value),
-            )
+            munderover_tag = ox_element("m#{tag_name}")
+            Utility.update_nodes(munderover_tag, value_array.insert(0, first_value))
             return munderover_tag if parameter_three.nil?
 
             Utility.update_nodes(
-              Utility.ox_element("mrow"),
+              ox_element("mrow"),
               [
                 munderover_tag,
                 parameter_three&.to_mathml_without_math_tag,
-              ].flatten.compact,
+              ],
             )
           else
             first_value
@@ -61,7 +68,7 @@ module Plurimath
           Utility.update_nodes(
             nary,
             [
-              narypr("∑"),
+              narypr(hide_function_name ? "" : "∑"),
               omml_parameter(parameter_one, display_style, tag_name: "sub"),
               omml_parameter(parameter_two, display_style, tag_name: "sup"),
               omml_parameter(parameter_three, display_style, tag_name: "e"),
@@ -77,6 +84,23 @@ module Plurimath
         def nary_attr_value
           "∑"
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            sum = self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            sum.hide_function_name = true
+            obj.update(sum)
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
+
+          parameter_three&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(Utility.filter_values(obj.value))
+          end
+        end
       end
     end
   end

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

@@ -7,11 +7,20 @@ module Plurimath
     module Function
       class Sup < UnaryFunction
         def to_mathml_without_math_tag
-          Utility.ox_element("mo") << "sup"
+          mo_tag = Utility.ox_element("mo") << "sup"
+          first_value = mathml_value
+          first_value = mathml_value&.insert(0, mo_tag) unless hide_function_name
+          Utility.update_nodes(
+            ox_element("mrow"),
+            first_value,
+          )
         end
 
         def to_omml_without_math_tag(display_style)
-          [r_element("sup", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("sup", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

data/lib/plurimath/math/function/table/array.rb

@@ -15,7 +15,7 @@ module Plurimath
           end
 
           def to_latex
-            "\\begin{array}#{array_args}#{latex_content}\\end{array}"
+            "\\begin{array}#{array_args || '.'}#{latex_content}\\end{array}"
           end
 
           def array_args

data/lib/plurimath/math/function/table/matrix.rb

@@ -14,6 +14,10 @@ module Plurimath
             super
           end
 
+          def to_asciimath
+            "{:#{value.map(&:to_asciimath).join(", ")}:}"
+          end
+
           def to_latex
             "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end

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

@@ -6,6 +6,8 @@ module Plurimath
       class Table < Core
         attr_accessor :value, :open_paren, :close_paren, :options
 
+        SIMPLE_TABLES = %w[array align split].freeze
+
         def initialize(value = nil,
                        open_paren = nil,
                        close_paren = nil,
@@ -25,6 +27,8 @@ module Plurimath
         end
 
         def to_asciimath
+          return parentheless_table if SIMPLE_TABLES.include?(class_name)
+
           parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
           first_value = value.map(&:to_asciimath).join(", ")
           third_value = close_paren.is_a?(::Array) || close_paren.nil?
@@ -52,13 +56,11 @@ module Plurimath
         end
 
         def to_latex
-          if open_paren == "norm["
-            return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}"
-          end
+          return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}" if open_paren == "norm["
 
           separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
-          left_paren = latex_parenthesis(open_paren) || "."
-          right_paren = latex_parenthesis(close_paren) || "."
+          left_paren = latex_parenthesis(open_paren)
+          right_paren = latex_parenthesis(close_paren)
           left = "\\left #{left_paren}\\begin{matrix}"
           right = "\\end{matrix}\\right #{right_paren}"
           "#{left}#{separator}#{latex_content}#{right}"
@@ -70,11 +72,40 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          if value.map { |d| d.parameter_one.length == 1 }.all?
-            single_td_table(display_style)
-          else
-            fenced_table(multiple_td_table(display_style))
-          end
+          ox_table = if value.map { |d| d.parameter_one.length == 1 }.all?
+                       single_td_table(display_style)
+                     else
+                       multiple_td_table(display_style)
+                     end
+          fenced_table(ox_table)
+        end
+
+        def to_asciimath_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"table\" function apply\n",
+            Formula.new(value).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"table\" function apply\n",
+            Formula.new(value).to_latex_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_mathml_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"table\" function apply\n",
+            Formula.new(value).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+          [
+            "#{spacing}\"table\" function apply\n",
+            Formula.new(value).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+          ]
         end
 
         protected
@@ -90,6 +121,7 @@ module Plurimath
         end
 
         def latex_parenthesis(field)
+          return "." unless field
           return " ." if field&.include?(":")
 
           return "\\#{field}" if ["{", "}"].include?(field)
@@ -165,7 +197,7 @@ module Plurimath
           eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
           eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
           eqarr    << eqarrpr
-          tr_value = value.map { |obj| obj.to_omml_without_math_tag(display_style) }.flatten
+          tr_value = value.map { |object| object.to_omml_without_math_tag(display_style) }.flatten
           Utility.update_nodes(eqarr, tr_value.compact)
           [eqarr]
         end
@@ -194,7 +226,7 @@ module Plurimath
           mcs << mc
           mpr << mcs
           mpr << ctrlpr
-          mm_value = value&.map { |obj| obj.to_omml_without_math_tag(display_style) }
+          mm_value = value&.map { |object| object.to_omml_without_math_tag(display_style) }
           Utility.update_nodes(
             mm,
             mm_value.insert(0, mpr).flatten,
@@ -215,7 +247,7 @@ module Plurimath
         end
 
         def fenced_table(ox_table)
-          return ox_table unless open_paren && close_paren
+          return ox_table unless open_paren || close_paren
 
           d_node = Utility.ox_element("d", namespace: "m")
           e_node = Utility.ox_element("e", namespace: "m")
@@ -225,22 +257,22 @@ module Plurimath
         end
 
         def mdpr_node
-          begchr = Utility.ox_element("begChr", namespace: "m")
-          begchr.attributes["m:val"] = paren(open_paren)
-          endchr = Utility.ox_element("endChr", namespace: "m")
-          endchr.attributes["m:val"] = paren(close_paren)
           sepchr = Utility.ox_element("sepChr", attributes: { "m:val": "" }, namespace: "m")
           mgrow  = Utility.ox_element("grow", namespace: "m")
           mdpr = Utility.ox_element("dPr", namespace: "m")
-          Utility.update_nodes(
-            mdpr,
-            [
-              begchr,
-              endchr,
-              sepchr,
-              mgrow,
-            ],
-          )
+          Utility.update_nodes(mdpr, [begchr, endchr, sepchr, mgrow])
+        end
+
+        def begchr
+          return unless open_paren
+
+          Utility.ox_element("begChr", attributes: { "m:val": paren(open_paren) }, namespace: "m")
+        end
+
+        def endchr
+          return unless close_paren
+
+          Utility.ox_element("endChr", attributes: { "m:val": paren(close_paren) }, namespace: "m")
         end
 
         def paren(parenthesis)
@@ -248,6 +280,10 @@ module Plurimath
 
           parenthesis
         end
+
+        def parentheless_table
+          "{:#{value.map(&:to_asciimath).join(", ")}:}"
+        end
       end
     end
   end

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

@@ -36,12 +36,50 @@ module Plurimath
           me = Utility.ox_element("e", namespace: "m")
           return [me] if parameter_one&.empty?
 
-          Utility.update_nodes(
-            me,
-            Formula.new(parameter_one).omml_content(display_style),
-          )
+          Utility.update_nodes(me, omml_content(display_style))
           [me]
         end
+
+        def to_asciimath_math_zone(spacing, last = false, _)
+          [
+            "#{spacing}\"td\" function apply\n",
+            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last),
+          ]
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"td\" function apply\n",
+            Formula.new(parameter_one).to_latex_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_mathml_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"td\" function apply\n",
+            Formula.new(parameter_one).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+          [
+            "#{spacing}\"td\" function apply\n",
+            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+          ]
+        end
+
+        def omml_content(display_style)
+          parameter_one&.map { |val| val.insert_t_tag(display_style) }
+        end
+
+        def line_breaking(obj)
+          sliced_value = result(Array(parameter_one))
+          return unless sliced_value.length > 1
+
+          sliced_result = sliced_value.first.last.omml_line_break(sliced_value)
+          table = Table.new(sliced_result.map { |res| Tr.new(Array(Td.new(Array(res)))) })
+          self.parameter_one = [table]
+        end
       end
     end
   end