plurimath 0.2.1 → 0.2.2

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

@@ -6,6 +6,33 @@ module Plurimath
   module Math
     module Function
       class Stackrel < BinaryFunction
+        def to_asciimath
+          first_value  = wrapped(parameter_one)
+          second_value = wrapped(parameter_two)
+          "#{class_name}#{first_value}#{second_value}"
+        end
+
+        def to_mathml_without_math_tag
+          mover = Utility.ox_element("mover")
+          first_value = Utility.ox_element("mrow")
+          first_value << parameter_one.to_mathml_without_math_tag if parameter_one
+          second_value = Utility.ox_element("mrow")
+          second_value << parameter_two.to_mathml_without_math_tag if parameter_two
+          Utility.update_nodes(mover, [second_value, first_value])
+        end
+
+        def to_html
+          first_value = parameter_one&.to_html
+          second_value = parameter_two&.to_html
+          "#{first_value}#{second_value}"
+        end
+
+        protected
+
+        def wrapped(field)
+          string = field&.to_asciimath || ""
+          string.start_with?("(") ? string : "(#{string})"
+        end
       end
     end
   end

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

@@ -11,6 +11,13 @@ module Plurimath
           second_value = "\\\\#{parameter_two.to_latex}" if parameter_two
           "\\#{class_name}{#{first_value}#{second_value}}"
         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)
+        end
       end
     end
   end

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

@@ -7,8 +7,8 @@ module Plurimath
     module Function
       class Sum < BinaryFunction
         def to_asciimath
-          first_value = "_(#{parameter_one.to_asciimath})" if parameter_one
-          second_value = "^(#{parameter_two.to_asciimath})" if parameter_two
+          first_value = "_#{wrapped(parameter_one)}" if parameter_one
+          second_value = "^#{wrapped(parameter_two)}" if parameter_two
           "sum#{first_value}#{second_value}"
         end
 
@@ -18,11 +18,59 @@ module Plurimath
           "\\sum#{first_value}#{second_value}"
         end
 
+        def to_mathml_without_math_tag
+          first_value = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          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
+            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),
+            )
+          else
+            first_value
+          end
+        end
+
         def to_html
           first_value = "<sub>#{parameter_one.to_html}</sub>" if parameter_one
           second_value = "<sup>#{parameter_two.to_html}</sup>" if parameter_two
           "<i>&sum;</i>#{first_value}#{second_value}"
         end
+
+        def to_omml_without_math_tag
+          limupp   = Utility.ox_element("limLow", namespace: "m")
+          limupppr = Utility.ox_element("limUppPr", namespace: "m")
+          sum << Utility.pr_element("e", true, namespace: "m")
+          me = (Utility.ox_element("e", namespace: "m") << omml_first_value)
+          lim = (Utility.ox_element("lim", namespace: "m") << omml_second_value)
+          Utility.update_nodes(limupp, [limupppr, me, lim])
+        end
+
+        protected
+
+        def omml_first_value
+          return parameter_one.to_omml_without_math_tag unless parameter_one.is_a?(Math::Symbol)
+
+          mt = Utility.ox_element("t", namespace: "m")
+          mt << parameter_one.to_omml_without_math_tag if parameter_one
+          mt
+        end
+
+        def omml_second_value
+          return parameter_two.to_omml_without_math_tag unless parameter_two.is_a?(Math::Symbol)
+
+          mt = Utility.ox_element("t", namespace: "m")
+          mt << parameter_two.to_omml_without_math_tag if parameter_two
+          mt
+        end
       end
     end
   end

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

@@ -6,6 +6,9 @@ module Plurimath
   module Math
     module Function
       class Sup < UnaryFunction
+        def to_mathml_without_math_tag
+          Utility.ox_element("mo") << "sup"
+        end
       end
     end
   end

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

@@ -7,15 +7,15 @@ module Plurimath
     module Function
       class Table
         class Align < Table
-          def initialize(parameter_one,
-                         parameter_two = "[",
-                         parameter_three = "]")
+          def initialize(value,
+                         open_paren = "[",
+                         close_paren = "]",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{align}#{first_value}\\end{align}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
         end
       end

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

@@ -7,16 +7,35 @@ module Plurimath
     module Function
       class Table
         class Array < Table
-          def initialize(parameter_one = [],
-                         parameter_two = "[",
-                         parameter_three = "]")
+          def initialize(value = [],
+                         open_paren = "[",
+                         close_paren = "]",
+                         options = {})
             super
           end
 
           def to_latex
-            divider     = "{#{parameter_three.map(&:to_latex).join}}"
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{array}#{divider}#{first_value}\\end{array}"
+            "\\begin{array}#{array_args}#{latex_content}\\end{array}"
+          end
+
+          def array_args
+            args = []
+            value.first.parameter_one.each do |td|
+              args << if Utility.symbol_value(td.parameter_one.first, "|")
+                        "|"
+                      else
+                        Utility::ALIGNMENT_LETTERS.invert[Hash(td.parameter_two)[:columnalign]]&.to_s
+                      end
+            end
+            "{#{args.join}}" unless args.compact.empty?
+          end
+
+          def to_mathml_without_math_tag
+            table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+            Utility.update_nodes(
+              table_tag,
+              value&.map(&:to_mathml_without_math_tag),
+            )
           end
         end
       end

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

@@ -7,17 +7,28 @@ module Plurimath
     module Function
       class Table
         class Bmatrix < Table
-          def initialize(parameter_one,
-                         parameter_two = "[",
-                         parameter_three = "]")
+          def initialize(value,
+                         open_paren = "[",
+                         close_paren = "]",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            matrices    = Latex::Constants::MATRICES.invert
-            environment = matrices[parameter_two].to_s
-            "\\begin{#{environment}}#{first_value}\\end{#{environment}}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
+          end
+
+          def to_mathml_without_math_tag
+            table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+            Utility.update_nodes(
+              table_tag,
+              value&.map(&:to_mathml_without_math_tag),
+            )
+            attributes = {
+              open: mathml_parenthesis(open_paren),
+              close: mathml_parenthesis(close_paren),
+            }
+            Utility.ox_element("mfenced", attributes: attributes) << table_tag
           end
         end
       end

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

@@ -7,15 +7,23 @@ module Plurimath
     module Function
       class Table
         class Matrix < Table
-          def initialize(parameter_one = [],
-                         parameter_two = "(",
-                         parameter_three = ")")
+          def initialize(value = [],
+                         open_paren = "(",
+                         close_paren = ")",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{matrix}#{first_value}\\end{matrix}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
+          end
+
+          def to_mathml_without_math_tag
+            table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+            Utility.update_nodes(
+              table_tag,
+              value&.map(&:to_mathml_without_math_tag),
+            )
           end
         end
       end

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

@@ -7,15 +7,15 @@ module Plurimath
     module Function
       class Table
         class Multline < Table
-          def initialize(parameter_one,
-                         parameter_two = "[",
-                         parameter_three = "]")
+          def initialize(value,
+                         open_paren = "[",
+                         close_paren = "]",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{multline}#{first_value}\\end{multline}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
         end
       end

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

@@ -7,15 +7,15 @@ module Plurimath
     module Function
       class Table
         class Pmatrix < Table
-          def initialize(parameter_one,
-                         parameter_two = "(",
-                         parameter_three = ")")
+          def initialize(value,
+                         open_paren = "(",
+                         close_paren = ")",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{pmatrix}#{first_value}\\end{pmatrix}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
         end
       end

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

@@ -7,15 +7,15 @@ module Plurimath
     module Function
       class Table
         class Split < Table
-          def initialize(parameter_one,
-                         parameter_two = "[",
-                         parameter_three = "]")
+          def initialize(value,
+                         open_paren = "[",
+                         close_paren = "]",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{split}#{first_value}\\end{split}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
         end
       end

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

@@ -7,16 +7,15 @@ module Plurimath
     module Function
       class Table
         class Vmatrix < Table
-          def initialize(parameter_one,
-                         parameter_two = "|",
-                         parameter_three = "|")
-            parameter_three = nil if parameter_two == "norm["
+          def initialize(value,
+                         open_paren = "|",
+                         close_paren = "|",
+                         options = {})
             super
           end
 
           def to_latex
-            first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-            "\\begin{vmatrix}#{first_value}\\end{vmatrix}"
+            "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
         end
       end

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

@@ -5,49 +5,207 @@ require_relative "ternary_function"
 module Plurimath
   module Math
     module Function
-      class Table < TernaryFunction
-        def initialize(parameter_one = nil,
-                       parameter_two = nil,
-                       parameter_three = nil)
-          super
+      class Table
+        attr_accessor :value, :open_paren, :close_paren, :options
+
+        def initialize(value = nil,
+                       open_paren = nil,
+                       close_paren = nil,
+                       options = {})
+          @value = value
+          @open_paren = open_paren
+          @close_paren = close_paren
+          @options = options
+        end
+
+        def ==(object)
+          object.class == self.class &&
+            object.value == value &&
+            object.options == options &&
+            object.open_paren == open_paren &&
+            object.close_paren == close_paren
         end
 
         def to_asciimath
-          first_value  = parameter_one.map(&:to_asciimath).join(",")
-          second_value = parameter_two.nil? ? "[" : parameter_two
-          third_value  = parameter_three.nil? ? "]" : parameter_three
-          "#{second_value}#{first_value}#{third_value}"
+          parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
+          first_value = value.map(&:to_asciimath).join(", ")
+          third_value = close_paren.is_a?(::Array) || close_paren.nil?
+          lparen = open_paren.nil? ? "[" : open_paren
+          rparen = third_value ? parenthesis[lparen.to_sym] : close_paren
+          "#{lparen}#{first_value}#{rparen}"
         end
 
         def to_mathml_without_math_tag
-          table_value = parameter_one.map(&:to_mathml_without_math_tag).join
-          parenthesis = Latex::Constants::PARENTHESIS
-          if parenthesis.key?(parameter_two) || parameter_two == "|"
-            "<mfenced open='#{parameter_two}' close='#{parameter_three}'>"\
-              "<mtable>#{table_value}</mtable></mfenced>"
-          elsif parameter_two == "norm["
-            "<mo>&#x2225;</mo>#{table_value}<mo>&#x2225;</mo>"
-          else
-            "<mtable>#{table_value}</mtable>"
+          table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+          Utility.update_nodes(
+            table_tag,
+            value&.map(&:to_mathml_without_math_tag),
+          )
+          return norm_table(table_tag) if open_paren == "norm["
+
+          if present?(open_paren) || present?(close_paren)
+            first_paren = Utility.ox_element("mo") << mathml_parenthesis(open_paren)
+            second_paren = Utility.ox_element("mo") << mathml_parenthesis(close_paren)
+            mrow_tag = Utility.ox_element("mrow")
+            return Utility.update_nodes(mrow_tag, [first_paren, table_tag, second_paren])
           end
+
+          table_tag
         end
 
         def to_latex
-          first_value = parameter_one&.map(&:to_latex)&.join("\\\\")
-          environment = latex_environment
-          "\\begin{#{environment}}#{first_value}\\end{#{environment}}"
-        end
+          if open_paren == "norm["
+            return "\\begin{Vmatrix}#{latex_content}\\end{Vmatrix}"
+          end
 
-        def latex_environment
-          matrices_hash = Latex::Constants::MATRICES
-          matric_value  = matrices_hash.value?(parameter_two)
-          matrices_hash.invert[parameter_two] if matric_value
+          separator = "{#{table_attribute(:latex)}}" if environment&.include?("array")
+          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}"
         end
 
         def to_html
-          first_value = parameter_one.map(&:to_html).join
+          first_value = value.map(&:to_html).join
           "<table>#{first_value}</table>"
         end
+
+        def to_omml_without_math_tag
+          if value.map { |d| d.parameter_one.length == 1 }.all?
+            single_td_table
+          else
+            multiple_td_table
+          end
+        end
+
+        def class_name
+          self.class.name.split("::").last.downcase
+        end
+
+        protected
+
+        def present?(field)
+          !(field.nil? || field.empty?)
+        end
+
+        def mathml_parenthesis(field)
+          return "" if field&.include?(":")
+
+          present?(field) ? field : ""
+        end
+
+        def latex_parenthesis(field)
+          return " ." if field&.include?(":")
+
+          return "\\#{field}" if ["{", "}"].include?(field)
+
+          field
+        end
+
+        def table_attribute(type = :mathml)
+          column_string = column_lines
+          case type
+          when :mathml
+            mathml_attrs(column_string)
+          when :latex
+            column_string.insert(0, "none") if column_string.include?("solid")
+            column_string&.map { |d| d == "solid" ? "|" : "a" }&.join
+          end
+        end
+
+        def column_lines
+          columns_array = []
+          value.first.parameter_one.each_with_index do |td, i|
+            if td.parameter_one.find { |obj| Utility.symbol_value(obj, "|") }
+              columns_array.empty? ? columns_array = ["solid"] : columns_array[i - 1] = "solid"
+            else
+              columns_array << "none"
+            end
+          end
+          columns_array
+        end
+
+        def mathml_attrs(column_strings)
+          args = options&.dup&.reject { |arg| arg.to_s == "asterisk" }
+          args[:columnlines] = column_strings.join(" ") if column_strings.include?("solid")
+          args
+        end
+
+        def latex_content
+          value&.map(&:to_latex)&.join(" \\\\ ")
+        end
+
+        def matrix_class
+          matrix = if open_paren
+                     Latex::Constants::MATRICES.invert[open_paren]
+                   else
+                     class_name
+                   end
+          options&.key?(:asterisk) ? "{#{matrix}*}" : "{#{matrix}}"
+        end
+
+        def opening
+          "#{matrix_class}#{latex_columnalign}"
+        end
+
+        def latex_columnalign
+          return "" unless Hash(options)[:asterisk]
+
+          columnalign = Hash(value&.first&.parameter_one&.first&.parameter_two)[:columnalign]
+          "[#{Utility::ALIGNMENT_LETTERS.invert[columnalign]}]"
+        end
+
+        def environment
+          matrices_hash = Latex::Constants::MATRICES
+          matric_value  = matrices_hash.value?(open_paren)
+          matrices_hash.invert[open_paren].to_s if matric_value
+        end
+
+        def single_td_table
+          eqarr    = Utility.ox_element("eqArr", namespace: "m")
+          eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
+          eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
+          eqarr    << eqarrpr
+          tr_value = value.map(&:to_omml_without_math_tag).flatten
+          Utility.update_nodes(eqarr, tr_value.compact)
+        end
+
+        def multiple_td_table
+          count  = { "m:val": value&.first&.parameter_one&.count }
+          mcjc   = { "m:val": "center" }
+          mm     = Utility.ox_element("m", namespace: "m")
+          mpr    = Utility.ox_element("mpr", namespace: "m")
+          mcs    = Utility.ox_element("mcs", namespace: "m")
+          mc     = Utility.ox_element("mc", namespace: "m")
+          mcpr   = Utility.ox_element("mcPr", namespace: "m")
+          mcount = Utility.ox_element(
+            "count",
+            namespace: "m",
+            attributes: count,
+          )
+          mcjc = Utility.ox_element(
+            "mcJc",
+            namespace: "m",
+            attributes: mcjc,
+          )
+          ctrlpr = Utility.pr_element("ctrl", true, namespace: "m")
+          Utility.update_nodes(mcpr, [mcount, mcjc])
+          mc  << mcpr
+          mcs << mc
+          mpr << mcs
+          mpr << ctrlpr
+          mm_value = value&.map(&:to_omml_without_math_tag)
+          Utility.update_nodes(mm, mm_value.insert(0, mpr).flatten)
+        end
+
+        def norm_table(table_tag)
+          mo_tag = Utility.ox_element("mo") << "&#x2225;"
+          Utility.update_nodes(
+            Utility.ox_element("mrow"),
+            [mo_tag, table_tag, mo_tag],
+          )
+        end
       end
     end
   end

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

@@ -1,31 +1,44 @@
 # frozen_string_literal: true
 
-require_relative "unary_function"
+require_relative "binary_function"
 
 module Plurimath
   module Math
     module Function
-      class Td < UnaryFunction
+      class Td < BinaryFunction
         def to_asciimath
-          if parameter_one.length > 1
-            "[#{parameter_one.map(&:to_asciimath).join(',')}]"
-          else
-            parameter_one.map(&:to_asciimath).join(",")
-          end
+          parameter_one.map(&:to_asciimath).join(" ")
         end
 
         def to_mathml_without_math_tag
-          "<mtd>#{parameter_one.map(&:to_mathml_without_math_tag).join}</mtd>"
+          return "" if Utility.symbol_value(parameter_one.first, "|")
+
+          td_attribute = parameter_two if parameter_two&.any?
+
+          Utility.update_nodes(
+            Utility.ox_element("mtd", attributes: td_attribute),
+            parameter_one.map(&:to_mathml_without_math_tag),
+          )
         end
 
         def to_latex
-          parameter_one.map(&:to_latex).join
+          return "" if Utility.symbol_value(parameter_one.first, "|")
+
+          parameter_one.map(&:to_latex).join(" ")
         end
 
         def to_html
           first_value = parameter_one.map(&:to_html).join
           "<td>#{first_value}</td>"
         end
+
+        def to_omml_without_math_tag
+          me = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(
+            me,
+            parameter_one&.map(&:to_omml_without_math_tag),
+          )
+        end
       end
     end
   end