plurimath 0.7.1 → 0.8.0

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

@@ -32,6 +32,14 @@ module Plurimath
           Utility.update_nodes(phant, [phant_pr, e_tag])
         end
 
+        def to_unicodemath
+          if parameter_one.is_a?(Math::Function::Mpadded) && parameter_one&.options&.dig(:phantom)
+            "#{phantom_unicode}#{unicodemath_parens(parameter_one.parameter_one)}"
+          else
+            "⟡#{unicodemath_parens(parameter_one)}"
+          end
+        end
+
         def line_breaking(obj)
           custom_array_line_breaking(obj)
         end
@@ -39,10 +47,18 @@ module Plurimath
         protected
 
         def phant_pr
-          attributes = { val: "m:off" }
-          phant = Utility.ox_element("phant", namespace: "m")
+          attributes = { "m:val": "off" }
+          phant = Utility.ox_element("phantPr", namespace: "m")
           phant << Utility.ox_element("show", namespace: "m", attributes: attributes)
         end
+
+        def phantom_symbol
+          UnicodeMath::Constants::PHANTOM_SYMBOLS.key(parameter_one.options)
+        end
+
+        def phantom_unicode
+          UnicodeMath::Constants::UNARY_SYMBOLS[phantom_symbol]
+        end
       end
     end
   end

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

@@ -53,6 +53,22 @@ module Plurimath
           [ssup_element]
         end
 
+        def to_unicodemath
+          if accented?(parameter_two)
+            "#{parameter_one.to_unicodemath}#{parameter_two.to_unicodemath}"
+          elsif parameter_two.mini_sized?
+            "#{parameter_one.to_unicodemath}#{parameter_two.to_unicodemath}"
+          else
+            first_value = parameter_one.to_unicodemath if parameter_one
+            second_value = if parameter_two.is_a?(self.class)
+              "^#{parameter_two.to_unicodemath}"
+            else
+              "^#{unicodemath_parens(parameter_two)}"
+            end
+            "#{first_value}#{second_value}"
+          end
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -60,6 +76,27 @@ module Plurimath
             self.parameter_two = nil
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, nil, parameter_two, fourth_value)
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        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
+
+        protected
+
+        def accented?(field)
+          (field.is_a?(Math::Symbol) && prime_unicode?(field)) ||
+            (field.is_a?(Math::Function::Power) && prime_unicode?(field.parameter_one))
+        end
       end
     end
   end

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

@@ -43,9 +43,7 @@ module Plurimath
 
           ssubsup   = Utility.ox_element("sSubSup", namespace: "m")
           ssubsuppr = Utility.ox_element("sSubSupPr", namespace: "m")
-          ssubsuppr << hide_tags(
-            Utility.pr_element("ctrl", true, namespace: "m"),
-          )
+          ssubsuppr << Utility.pr_element("ctrl", true, namespace: "m")
           Utility.update_nodes(
             ssubsup,
             [
@@ -58,6 +56,16 @@ module Plurimath
           [ssubsup]
         end
 
+        def to_unicodemath
+          first_value = sub_value if parameter_two
+          second_value = sup_value if parameter_three
+          if prime_unicode?(parameter_three)
+            "#{parameter_one&.to_unicodemath}#{second_value}#{first_value}"
+          else
+            "#{parameter_one&.to_unicodemath}#{first_value}#{second_value}"
+          end
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -78,25 +86,44 @@ module Plurimath
           end
         end
 
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, parameter_two, parameter_three, fourth_value)
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        end
+
+        def mmultiscript
+          [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_three),
+          ]
+        end
+
         protected
 
-        def hide_tags(nar)
-          attr = { "m:val": "1" }
-          if parameter_two.nil?
-            nar << Utility.ox_element(
-              "subHide",
-              namespace: "m",
-              attributes: attr,
-            )
+        def sup_value
+          if parameter_three.mini_sized? || prime_unicode?(parameter_three)
+            parameter_three.to_unicodemath
+          elsif parameter_three.is_a?(Math::Function::Power)
+            "^#{parameter_three.to_unicodemath}"
+          elsif parameter_one.is_a?(Math::Function::Power) && parameter_one&.prime_unicode?(parameter_one&.parameter_two)
+            "^#{parameter_three.to_unicodemath}"
+          else
+            "^#{unicodemath_parens(parameter_three)}"
           end
-          if parameter_three.nil?
-            nar << Utility.ox_element(
-              "supHide",
-              namespace: "m",
-              attributes: attr,
-            )
+        end
+
+        def sub_value
+          if parameter_two.mini_sized?
+            parameter_two.to_unicodemath
+          elsif parameter_two.is_a?(Math::Function::Base)
+            "_#{parameter_two.to_unicodemath}"
+          else
+            "_#{unicodemath_parens(parameter_two)}"
           end
-          nar
         end
       end
     end

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Prod < TernaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "prod",
           first_value: "subscript",
           second_value: "supscript",
         }.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
@@ -71,6 +84,13 @@ module Plurimath
           [nary]
         end
 
+        def to_unicodemath
+          first_value = sub_value if parameter_one
+          second_value = sup_value if parameter_two
+          mask = options&.dig(:mask) if options&.key?(:mask)
+          "#{nary_attr_value}#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three)}"
+        end
+
         def nary_values(display_style)
           [
             narypr(hide_function_name ? "" : nary_attr_value),
@@ -98,6 +118,32 @@ module Plurimath
             obj.update(Utility.filter_values(obj.value))
           end
         end
+
+        def is_nary_function?
+          true
+        end
+
+        protected
+
+        def sup_value
+          if parameter_two&.mini_sized? || prime_unicode?(parameter_two)
+            parameter_two.to_unicodemath
+          elsif parameter_two.is_a?(Math::Function::Power)
+            "^#{parameter_two.to_unicodemath}"
+          else
+            "^#{unicodemath_parens(parameter_two)}"
+          end
+        end
+
+        def sub_value
+          if parameter_one&.mini_sized?
+            parameter_one.to_unicodemath
+          elsif parameter_one.is_a?(Math::Function::Base)
+            "_#{parameter_one.to_unicodemath}"
+          else
+            "_#{unicodemath_parens(parameter_one)}"
+          end
+        end
       end
     end
   end

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

@@ -33,6 +33,10 @@ module Plurimath
           "\\right #{latex_paren}"
         end
 
+        def to_unicodemath
+          parameter_one
+        end
+
         def validate_function_formula
           false
         end

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