plurimath 0.7.2 → 0.8.1

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

@@ -12,19 +12,47 @@ module Plurimath
           third_value: "supscript",
         }.freeze
 
+        def to_asciimath
+          subscript = "_(#{parameter_two&.map(&:to_asciimath).join})" unless valid_value_exist?(parameter_two)
+          supscript = "^(#{parameter_three&.map(&:to_asciimath).join})" unless valid_value_exist?(parameter_three)
+          prescript = "\\ #{subscript}#{supscript}" if subscript || supscript
+          "#{prescript}#{parameter_one&.to_asciimath}"
+        end
+
+        def to_latex
+          subscript = "_{#{parameter_two&.map(&:to_latex).join}}" unless valid_value_exist?(parameter_two)
+          supscript = "^{#{parameter_three&.map(&:to_latex).join}}" unless valid_value_exist?(parameter_three)
+          prescript = "{}#{subscript}#{supscript}" if subscript || supscript
+          "#{prescript}#{parameter_one&.to_latex}"
+        end
+
+        def to_mathml_without_math_tag
+          mprescript = ox_element("mprescripts") if (parameter_two || parameter_three)
+          Utility.update_nodes(
+            ox_element("mmultiscripts"),
+            [
+              parameter_one&.mmultiscript,
+              mprescript,
+              validate_mathml_fields(prescripts),
+            ]
+          )
+        end
+
         def to_omml_without_math_tag(display_style)
-          pre_element = Utility.ox_element("sPre", namespace: "m")
-          pr_element  = Utility.ox_element("sPrePr", namespace: "m")
           Utility.update_nodes(
-            pre_element,
+            ox_element("sPre", namespace: "m"),
             [
-              pr_element << Utility.pr_element("ctrl", true, namespace: "m"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
               omml_parameter(parameter_two, display_style, tag_name: "sub"),
               omml_parameter(parameter_three, display_style, tag_name: "sup"),
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
-          [pre_element]
+        end
+
+        def to_unicodemath
+          first_value = sub_value if unicode_valid_value?(parameter_two)
+          second_value = sup_value if unicode_valid_value?(parameter_three)
+          "#{first_value}#{second_value} #{parameter_one&.to_unicodemath}"
         end
 
         def line_breaking(obj)
@@ -46,6 +74,42 @@ module Plurimath
             self.parameter_three = nil
           end
         end
+
+        private
+
+        def prescripts
+          Array(parameter_two)&.zip(Array(parameter_three))&.flatten&.compact
+        end
+
+        def valid_value_exist?(field)
+          !field && (field&.empty? || field&.all?(None))
+        end
+
+        def unicode_valid_value?(field)
+          !field.empty? && !valid_value_exist?(field)
+        end
+
+        def sup_value
+          field = Utility.filter_values(parameter_two)
+          if field&.mini_sized? || prime_unicode?(field)
+            parameter_three.map(&:to_unicodemath).join
+          elsif field.is_a?(Math::Function::Power)
+            "^#{parameter_three.map(&:to_unicodemath).join}"
+          elsif parameter_three && !parameter_three.empty?
+            "^(#{parameter_three.map(&:to_unicodemath).join})"
+          end
+        end
+
+        def sub_value
+          field = Utility.filter_values(parameter_two)
+          if field&.mini_sized?
+            parameter_two.map(&:to_unicodemath).join
+          elsif parameter_two.is_a?(Math::Function::Base)
+            "_#{parameter_two.map(&:to_unicodemath).join}"
+          elsif parameter_two && !parameter_two.empty?
+            "_(#{parameter_two.map(&:to_unicodemath).join})"
+          end
+        end
       end
     end
   end

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

@@ -30,22 +30,31 @@ module Plurimath
 
         def to_asciimath
           first_value  = parameter_one&.to_asciimath || "int"
-          second_value = "_#{parameter_two.to_asciimath}" if parameter_two
-          third_value  = "^#{parameter_three.to_asciimath}" if parameter_three
+          second_value = "_(#{parameter_two.to_asciimath})" if parameter_two
+          third_value  = "^(#{parameter_three.to_asciimath})" if parameter_three
           fourth_value = " #{parameter_four.to_asciimath}" if parameter_four
           "#{first_value}#{second_value}#{third_value}#{fourth_value}"
         end
 
         def to_latex
           first_value  = parameter_one&.to_latex || "\\int"
-          second_value = "_#{parameter_two.to_latex}" if parameter_two
-          third_value  = "^#{parameter_three.to_latex}" if parameter_three
-          fourth_value = "{#{parameter_four.to_latex}}" if parameter_four
+          second_value = "_{#{parameter_two.to_latex}}" if parameter_two
+          third_value  = "^{#{parameter_three.to_latex}}" if parameter_three
+          fourth_value = " #{parameter_four.to_latex}" if parameter_four
           "#{first_value}#{second_value}#{third_value}#{fourth_value}"
         end
 
         def to_mathml_without_math_tag
           tag_name = options[:type] == "undOvr" ? "munderover" : "msubsup"
+          if !(parameter_two && parameter_three)
+            tag_name = if parameter_two
+                         tag_name == "munderover" ? "munder" : "msub"
+                       elsif parameter_three
+                         tag_name == "munderover" ? "mover" : "msup"
+                       else
+                        'mrow'
+                       end
+          end
           subsup_tag = ox_element(tag_name)
           new_arr = [
             validate_mathml_fields(parameter_one),
@@ -56,10 +65,10 @@ module Plurimath
           return subsup_tag unless parameter_four
 
           Utility.update_nodes(
-            ox_element("mrow"),
+            row_tag,
             [
               subsup_tag,
-              parameter_four&.to_mathml_without_math_tag,
+              (row_tag << validate_mathml_fields(parameter_four)),
             ],
           )
         end
@@ -70,10 +79,20 @@ module Plurimath
           Array(nary_element)
         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}#{naryand_value(parameter_four)}"
+          else
+            "#{parameter_one&.to_unicodemath}#{first_value}#{second_value}#{naryand_value(parameter_four)}"
+          end
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            obj.update(self.class.new(Utility.filter_values(obj.value), self.parameter_two, self.parameter_three, self.parameter_four))
+            obj.update(self.class.new(Utility.filter_values(obj.value), self.parameter_two, self.parameter_three, self.parameter_four, self.options))
             self.parameter_two = nil
             self.parameter_three = nil
             self.parameter_four = nil
@@ -82,7 +101,7 @@ module Plurimath
 
           parameter_two&.line_breaking(obj)
           if obj.value_exist?
-            obj.update(self.class.new(nil, Utility.filter_values(obj.value), self.parameter_three, self.parameter_four))
+            obj.update(self.class.new(nil, Utility.filter_values(obj.value), self.parameter_three, self.parameter_four, self.options))
             self.parameter_three = nil
             self.parameter_four = nil
             return
@@ -100,7 +119,7 @@ module Plurimath
           first_value = Utility.html_entity_to_unicode(parameter_one&.nary_attr_value)
           narypr << Utility.ox_element("chr", namespace: "m", attributes: { "m:val": first_value }) unless first_value == "∫"
 
-          narypr << Utility.ox_element("limLoc", namespace: "m", attributes: { "m:val": options[:type].to_s })
+          narypr << Utility.ox_element("limLoc", namespace: "m", attributes: { "m:val": (options[:type] || "subSup").to_s })
           hide_tags(narypr, parameter_two, "sub")
           hide_tags(narypr, parameter_three, "sup")
           narypr
@@ -122,6 +141,46 @@ module Plurimath
             omml_parameter(parameter_four, display_style, tag_name: "e"),
           ]
         end
+
+        def row_tag
+          Utility.ox_element("mrow")
+        end
+
+        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
+        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
+        end
+
+        def prime_unicode?(field)
+          return unless field.is_a?(Math::Symbol)
+          return true if field.value.include?("&#x27;")
+
+          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) }
+        end
+
+        def naryand_value(field)
+          return "" unless field
+
+          field_value = field.to_unicodemath
+          field.is_a?(Math::Function::Fenced) ? "▒#{field_value}" : "▒〖#{field_value}〗"
+        end
       end
     end
   end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class None < UnaryFunction
+        def to_asciimath; end
+
+        def to_latex; end
+
+        def to_mathml_without_math_tag
+          ox_element("none")
+        end
+
+        def to_omml_without_math_tag(_)
+          empty_tag
+        end
+
+        def to_unicodemath; end
+      end
+    end
+  end
+end

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

@@ -24,6 +24,12 @@ module Plurimath
           Utility.update_nodes(ox_element("mrow"), first_value)
         end
 
+        def to_unicodemath
+          first_value = "‖" unless open_paren
+          second_value = "‖" unless close_paren
+          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+        end
+
         def to_omml_without_math_tag(display_style)
           array = []
           array << r_element("∥") unless open_paren

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

@@ -53,6 +53,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "⏞(#{parameter_one&.to_unicodemath})"
+        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/oint.rb

@@ -6,11 +6,24 @@ module Plurimath
   module Math
     module Function
       class Oint < TernaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "contour integral",
           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
@@ -75,6 +88,13 @@ module Plurimath
           end
         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 line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -91,6 +111,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/over.rb

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

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

@@ -6,18 +6,27 @@ module Plurimath
   module Math
     module Function
       class Overset < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "overset",
           first_value: "base",
           second_value: "supscript",
         }.freeze
 
+        def initialize(
+          parameter_one = nil,
+          parameter_two = nil,
+          options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
         def to_mathml_without_math_tag
           value_array = [
             validate_mathml_fields(parameter_two),
             validate_mathml_fields(parameter_one),
           ]
-          Utility.update_nodes(ox_element("mover"), value_array)
+          Utility.update_nodes(ox_element("mover", attributes: options), value_array)
         end
 
         def to_omml_without_math_tag(display_style)
@@ -40,6 +49,15 @@ module Plurimath
           [limupp]
         end
 
+        def to_unicodemath
+          return "#{unicodemath_parens(parameter_two)}#{parameter_one.value}" if unicode_accent?(parameter_one)
+          return "#{parameter_one.value}#{parameter_two.to_unicodemath}" if unicode_accent?(parameter_two)
+          return "#{parameter_one.to_unicodemath}#{unicodemath_parens(parameter_two)}" if horizontal_brackets?
+          return "#{parameter_two.to_unicodemath}^#{unicodemath_parens(parameter_one)}" if unicode_classes_accent?(parameter_two)
+
+          "#{unicodemath_parens(parameter_two)}┴#{unicodemath_parens(parameter_one)}" if parameter_one || parameter_two
+        end
+
         def line_breaking(obj)
           parameter_two&.line_breaking(obj)
           if obj.value_exist?
@@ -47,6 +65,33 @@ module Plurimath
             self.parameter_one = nil
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_two, nil, parameter_one, fourth_value, { type: "undOvr" })
+        end
+
+        def is_nary_function?
+          parameter_two.is_nary_function? || parameter_two.is_nary_symbol?
+        end
+
+        protected
+
+        def unicode_accent?(field)
+          field.is_a?(Math::Symbol) &&
+            (
+              UnicodeMath::Constants::DIACRITIC_OVERLAYS.include?(field.value) ||
+                UnicodeMath::Constants::ACCENT_SYMBOLS.has_value?(field.value)
+            )
+        end
+
+        def unicode_classes_accent?(field)
+          (field.is_a?(Math::Function::Obrace) || field.is_a?(Math::Function::Ubrace))
+        end
+
+        def horizontal_brackets?
+          parameter_one.is_a?(Math::Symbol) &&
+            UnicodeMath::Constants::HORIZONTAL_BRACKETS.value?(parameter_one.value)
+        end
       end
     end
   end

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