plurimath 0.7.2 → 0.8.1

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

@@ -31,18 +31,26 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
+          attribute = { "m:val": "off" }
           rad_element = Utility.ox_element("rad", namespace: "m")
           pr_element  = Utility.ox_element("radPr", namespace: "m")
+          pr_element << Utility.ox_element("degHide", namespace: "m", attributes: attribute)
           Utility.update_nodes(
             rad_element,
             [
-              (pr_element << Utility.pr_element("ctrl", true, namespace: "m")),
+              pr_element,
               omml_parameter(parameter_two, display_style, tag_name: "deg"),
               omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [rad_element]
         end
+
+        def to_unicodemath
+          first_value = parameter_one.to_unicodemath if parameter_one
+          second_value = parameter_two.to_unicodemath if parameter_two
+          "√(#{first_value}&#{second_value})"
+        end
       end
     end
   end

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

@@ -34,6 +34,10 @@ module Plurimath
         def to_html
           ""
         end
+
+        def to_unicodemath
+          ""
+        end
       end
     end
   end

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

@@ -6,6 +6,8 @@ module Plurimath
   module Math
     module Function
       class Sqrt < UnaryFunction
+        attr_accessor :options
+
         def to_mathml_without_math_tag
           sqrt_tag = Utility.ox_element("msqrt")
           Utility.update_nodes(
@@ -21,7 +23,7 @@ module Plurimath
           pr_element << Utility.ox_element(
             "degHide",
             namespace: "m",
-            attributes: { "m:val": "1" },
+            attributes: { "m:val": "on" },
           )
           Utility.update_nodes(
             rad_element,
@@ -38,6 +40,10 @@ module Plurimath
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
         end
+
+        def to_unicodemath
+          "√#{unicodemath_parens(parameter_one)}"
+        end
       end
     end
   end

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

@@ -48,6 +48,12 @@ module Plurimath
           [limupp]
         end
 
+        def to_unicodemath
+          first_value = "(#{parameter_one&.to_unicodemath})"
+          second_value = "(#{parameter_two&.to_unicodemath})"
+          "#{second_value}┴#{first_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -30,6 +30,10 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           Table.new(parameter_one).to_omml_without_math_tag(display_style)
         end
+
+        def to_unicodemath
+          "■(#{parameter_one.compact.map(&:to_unicodemath).join("@")})"
+        end
       end
     end
   end

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

@@ -6,6 +6,7 @@ module Plurimath
   module Math
     module Function
       class Sum < TernaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "summation",
           first_value: "subscript",
@@ -13,6 +14,18 @@ module Plurimath
           third_value: "term",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       parameter_three = nil,
+                       options = {})
+          super(parameter_one, parameter_two, parameter_three)
+          @options = options unless options&.empty?
+        end
+
+        def ==(object)
+          super(object) && object.options == options
+        end
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -28,31 +41,28 @@ module Plurimath
         def to_mathml_without_math_tag
           first_value = ox_element("mo")
           first_value << invert_unicode_symbols.to_s unless hide_function_name
+          return first_value unless all_values_exist?
 
-          if parameter_one || parameter_two
-            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 = 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(
-              ox_element("mrow"),
-              [
-                munderover_tag,
-                parameter_three&.to_mathml_without_math_tag,
-              ],
-            )
-          else
-            first_value
-          end
+          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))
+          return munderover_tag if parameter_three.nil?
+
+          Utility.update_nodes(
+            ox_element("mrow"),
+            [
+              munderover_tag,
+              parameter_three&.to_mathml_without_math_tag,
+            ],
+          )
         end
 
         def to_html
@@ -61,6 +71,13 @@ module Plurimath
           "<i>&sum;</i>#{first_value}#{second_value}"
         end
 
+        def to_unicodemath
+          first_value = "_#{unicodemath_parens(parameter_one)}" if parameter_one
+          second_value = "^#{unicodemath_parens(parameter_two)}" if parameter_two
+          mask = options&.dig(:mask) if options&.key?(:mask)
+          "∑#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three)}"
+        end
+
         def to_omml_without_math_tag(display_style)
           return r_element("&#x2211;", rpr_tag: false) unless all_values_exist?
 
@@ -101,6 +118,10 @@ module Plurimath
             obj.update(Utility.filter_values(obj.value))
           end
         end
+
+        def is_nary_function?
+          true
+        end
       end
     end
   end

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

@@ -24,11 +24,24 @@ module Plurimath
               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
+            Utility.update_nodes(
+              Utility.ox_element("mrow"),
+              [
+                mo_element(mathml_parenthesis(open_paren)),
+                table_tag,
+                mo_element(mathml_parenthesis(close_paren)),
+              ],
+            )
+          end
+
+          def to_unicodemath
+            "#{matrix_symbol}(#{value.map(&:to_unicodemath).join("@")})"
+          end
+
+          private
+
+          def matrix_symbol
+            open_paren == "{" ? "Ⓢ" : "ⓢ"
           end
         end
       end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../table"
+
+module Plurimath
+  module Math
+    module Function
+      class Table
+        class Cases < Table
+          def initialize(value = [],
+                         open_paren = "{",
+                         close_paren = ":}",
+                         options = {})
+            super
+          end
+
+          def to_unicodemath
+            "Ⓒ(#{value.map(&:to_unicodemath).join("@")})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../table"
+
+module Plurimath
+  module Math
+    module Function
+      class Table
+        class Eqarray < Table
+          def initialize(value = [],
+                         open_paren = "",
+                         close_paren = "",
+                         options = {})
+            super
+          end
+
+          def to_unicodemath
+            "#{open_paren}█(#{value&.map(&:to_unicodemath).join("@")})#{close_paren}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,12 +23,32 @@ module Plurimath
           end
 
           def to_mathml_without_math_tag
-            table_tag = Utility.ox_element("mtable", attributes: table_attribute)
+            table_tag = Utility.update_nodes(
+              ox_element("mtable", attributes: table_attribute),
+              value&.map(&:to_mathml_without_math_tag)
+            )
+            return table_tag if table_tag_only?
+
             Utility.update_nodes(
-              table_tag,
-              value&.map(&:to_mathml_without_math_tag),
+              ox_element("mrow"),
+              [mo_tag(open_paren), table_tag, mo_tag(close_paren)]
             )
           end
+
+          def to_unicodemath
+            first_value = value.map(&:to_unicodemath).join("@")
+            "#{open_paren}■(#{first_value})#{close_paren}"
+          end
+
+          protected
+
+          def mo_tag(paren)
+            (ox_element("mo") << paren) unless validate_paren(paren)
+          end
+
+          def table_tag_only?
+            (open_paren&.include?("(") && close_paren&.include?(")")) || !(open_paren && close_paren)
+          end
         end
       end
     end

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

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

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

@@ -17,6 +17,16 @@ module Plurimath
           def to_latex
             "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end
+
+          def to_unicodemath
+            "#{matrix_symbol}(#{value.map(&:to_unicodemath).join("@")})"
+          end
+
+          private
+
+          def matrix_symbol
+            open_paren == "norm[" ? "⒩" : "⒱"
+          end
         end
       end
     end

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

@@ -46,8 +46,8 @@ module Plurimath
           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)
+            first_paren = mo_element(mathml_parenthesis(open_paren))
+            second_paren = mo_element(mathml_parenthesis(close_paren))
             mrow_tag = Utility.ox_element("mrow")
             return Utility.update_nodes(mrow_tag, [first_paren, table_tag, second_paren])
           end
@@ -72,7 +72,7 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          ox_table = if value.map { |d| d.parameter_one.length == 1 }.all?
+          ox_table = if single_table?
                        single_td_table(display_style)
                      else
                        multiple_td_table(display_style)
@@ -80,6 +80,14 @@ module Plurimath
           fenced_table(ox_table)
         end
 
+        def to_unicodemath
+          if unicodemath_table_class?
+            "#{unicodemath_class_name}(#{value.map(&:to_unicodemath).join("@")})"
+          else
+            "#{open_paren}■(#{value.map(&:to_unicodemath).join("@")})#{close_paren}"
+          end
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           [
             "#{spacing}\"table\" function apply\n",
@@ -115,7 +123,7 @@ module Plurimath
         end
 
         def mathml_parenthesis(field)
-          return "" if field&.include?(":")
+          return "" if field&.include?(":") || validate_paren(field)
 
           present?(field) ? field : ""
         end
@@ -235,13 +243,12 @@ module Plurimath
         end
 
         def norm_table(table_tag)
-          mo_tag = Utility.ox_element("mo") << "&#x2225;"
           Utility.update_nodes(
             Utility.ox_element("mrow"),
             [
-              mo_tag,
+              mo_element("&#x2016;"),
               table_tag,
-              mo_tag,
+              mo_element("&#x2016;"),
             ],
           )
         end
@@ -284,6 +291,50 @@ module Plurimath
         def parentheless_table
           "{:#{value.map(&:to_asciimath).join(", ")}:}"
         end
+
+        def single_table?
+          value.map { |d| d.parameter_one.length == 1 }.all? &&
+            nil_option?(:frame) &&
+            nil_option?(:columnlines) &&
+            nil_option?(:rowlines)
+        end
+
+        def nil_option?(option)
+          options[option].nil? ||
+            options[option] == "" ||
+            options[option] == "none"
+        end
+
+        def validate_paren(paren)
+          ["&#x3016;", "&#x3017;"].include?(paren)
+        end
+
+        def mo_element(value)
+          Utility.ox_element("mo") << value
+        end
+
+        def unicodemath_table_class?
+          return unless class_name == "table"
+          return if open_paren.nil? && close_paren.nil?
+
+          (!(open_paren.nil? || open_paren.empty?) && !(close_paren.nil? || close_paren.empty?)) ||
+            Utility::PARENTHESIS[open_paren&.to_sym] == close_paren ||
+            (open_paren.include?("|") && close_paren.include?("|"))
+        end
+
+        def unicodemath_class_name
+          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren == "norm["
+          return matrices_functions(:vmatrix) if open_paren == "|" && close_paren == "|"
+          return matrices_functions(:matrix) if class_name == "Bmatrix" && open_paren == "{"
+          return unless unicodemath_table_class?
+
+          matrix_name = UnicodeMath::Constants::PARENTHESIS_MATRICES.key(open_paren)
+          matrices_functions(matrix_name)
+        end
+
+        def matrices_functions(matrix_name)
+          UnicodeMath::Constants::MATRIXS[matrix_name]
+        end
       end
     end
   end

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

@@ -6,6 +6,11 @@ module Plurimath
   module Math
     module Function
       class Td < BinaryFunction
+        def initialize(parameter_one = nil, parameter_two = nil)
+          parameter_one&.delete_if { |td| td == "&" }
+          super(parameter_one, parameter_two)
+        end
+
         def to_asciimath
           parameter_one.map(&:to_asciimath).join(" ")
         end
@@ -40,6 +45,10 @@ module Plurimath
           [me]
         end
 
+        def to_unicodemath
+          parameter_one&.map(&:to_unicodemath)&.join
+        end
+
         def to_asciimath_math_zone(spacing, last = false, _)
           [
             "#{spacing}\"td\" function apply\n",

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

@@ -125,7 +125,7 @@ module Plurimath
 
         def ascii_wrap(field)
           asciimath = field.to_asciimath
-          return latex if ["obrace", "ubrace"].include?(field.class_name)
+          return asciimath if ["obrace", "ubrace"].include?(field.class_name)
 
           case field
           when Formula || field.class.name.include?("Function")
@@ -180,6 +180,19 @@ module Plurimath
 
           Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style)
         end
+
+        def naryand_value(field)
+          return "" unless field
+
+          field_value = field.to_unicodemath
+          field.is_a?(Math::Function::Fenced) ? "▒#{field_value}" : "▒〖#{field_value}〗"
+        end
+
+        def prime_unicode?(field)
+          return unless field.is_a?(Math::Symbol)
+
+          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) || field.value.include?("'") }
+        end
       end
     end
   end

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

@@ -35,6 +35,12 @@ module Plurimath
           [text]
         end
 
+        def to_unicodemath
+          return unless value
+
+          value&.start_with?("\\") ? value : "\"#{(Utility.html_entity_to_unicode(value))}\""
+        end
+
         def insert_t_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
           Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style))

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

@@ -36,6 +36,10 @@ module Plurimath
           false
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̃"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

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

@@ -6,6 +6,11 @@ module Plurimath
   module Math
     module Function
       class Tr < UnaryFunction
+        def initialize(parameter_one = [])
+          parameter_one.map!.with_index { |_, index| Td.new([]) } if parameter_one&.all?("@")
+          super(parameter_one)
+        end
+
         def to_asciimath
           "[#{parameter_one.map(&:to_asciimath).join(', ')}]"
         end
@@ -45,6 +50,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          parameter_one&.map(&:to_unicodemath)&.join("&")
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           [
             "#{spacing}\"tr\" function apply\n",

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

@@ -57,6 +57,11 @@ module Plurimath
           Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
 
+        def to_unicodemath
+          first_value = "(#{parameter_one&.to_unicodemath})" if parameter_one
+          "⏟#{first_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

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

@@ -49,6 +49,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "▁#{unicodemath_parens(parameter_one)}"
+        end
+
         def class_name
           "underline"
         end

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

@@ -64,6 +64,10 @@ module Plurimath
           Array(value)
         end
 
+        def to_unicodemath
+          "#{class_name}⁡#{parameter_one&.to_unicodemath}"
+        end
+
         def to_asciimath_math_zone(spacing, last = false, _)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [

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

@@ -47,6 +47,12 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          sub_value = "┬#{unicodemath_parens(parameter_two)}" if parameter_two
+          sup_value = "┴#{unicodemath_parens(parameter_three)}" if parameter_three
+          "#{parameter_one&.to_unicodemath}#{sub_value}#{sup_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -67,6 +73,14 @@ module Plurimath
             self.parameter_three = nil
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, parameter_two, parameter_three, fourth_value, { type: "undOvr" })
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        end
       end
     end
   end