plurimath 0.7.1 → 0.8.0

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Mglyph < UnaryFunction
+        def initialize(parameter_one = {})
+          super(parameter_one)
+        end
+
+        def to_asciimath
+          parameter_one[:alt]
+        end
+
+        def to_latex
+          parameter_one[:alt]
+        end
+
+        def to_mathml_without_math_tag
+          ox_element(class_name, attributes: parameter_one)
+        end
+
+        def to_omml_without_math_tag(_)
+          index = parameter_one[:index].to_i
+          r_element(
+            (ignoring_index(index) ? parameter_one[:alt].to_s : "&#x#{glyph_user_index(index)};"),
+            rpr_tag: false,
+          )
+        end
+
+        def to_unicodemath
+          parameter_one[:alt] if parameter_one
+        end
+
+        protected
+
+        def glyph_user_index(index)
+          return "" unless index > 0
+
+          remaining = index.modulo(16)
+          hex_bits = glyph_user_index(index / 16)
+          hex_digit = case remaining
+          when 0..9 then remaining.to_s
+          when 10 then "A"
+          when 11 then "B"
+          when 12 then "C"
+          when 13 then "D"
+          when 14 then "E"
+          when 15 then "F"
+          end
+          "#{hex_bits}#{hex_digit}"
+        end
+
+        def ignoring_index(index)
+          index.zero? ||
+            (index < 32 && !([9, 10, 13].include?(index))) ||
+            [65534, 65535].include?(index)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Mlabeledtr < BinaryFunction
+        def to_mathml_without_math_tag
+          table = ox_element("mtable")
+          mlabeledtr = ox_element(class_name)
+          labeledtr_td(mlabeledtr, parameter_two.to_mathml_without_math_tag)
+          labeledtr_td(mlabeledtr, parameter_one.to_mathml_without_math_tag)
+          table << mlabeledtr
+        end
+
+        def to_unicodemath
+          "#{parameter_one&.to_unicodemath}##{parameter_two&.value}"
+        end
+
+        protected
+
+        def labeledtr_td(tr, value)
+          tr << (ox_element("mtd") << value)
+        end
+      end
+    end
+  end
+end

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

@@ -47,6 +47,10 @@ module Plurimath
           values
         end
 
+        def to_unicodemath
+          "#{parameter_one&.to_unicodemath}mod#{parameter_two&.to_unicodemath}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Mpadded < UnaryFunction
+        attr_accessor :options
+        ZERO_TAGS = {
+          height: "zeroAsc",
+          depth: "zeroDesc",
+          width: "zeroWid",
+        }
+
+        def initialize(parameter_one = nil, options = {})
+          super(parameter_one)
+          @options = options unless options.empty?
+        end
+
+        def ==(object)
+          super(object) &&
+            object&.options == options
+        end
+
+        def to_asciimath
+          asciimath_value
+        end
+
+        def to_latex
+          latex_value
+        end
+
+        def to_mathml_without_math_tag
+          Utility.update_nodes(
+            ox_element(class_name, attributes: options),
+            Array(mathml_value),
+          )
+        end
+
+        def to_omml_without_math_tag(display_style)
+          phant   = ox_element("phant", namespace: "m")
+          phantpr = ox_element("phantPr", namespace: "m")
+          Utility.update_nodes(phantpr, phant_pr)
+          phant << phantpr unless phantpr.nodes.empty?
+
+          phant << omml_parameter(parameter_one, display_style, tag_name: "e")
+        end
+
+        def to_unicodemath
+          if options&.dig(:mpadded)
+            "#{mpadded_unicode}#{unicodemath_parens(parameter_one)}"
+          elsif options&.key?(:mask)
+            "⟡(#{options.dig(:mask)}&#{parameter_one&.to_unicodemath})"
+          else
+            first_value = "(#{parameter_one.to_unicodemath})" if parameter_one
+            "⟡#{first_value}"
+          end
+        end
+
+        protected
+
+        def phant_pr
+          attributes = { "m:val": "on" }
+          options.map do |atr, value|
+            ox_element(ZERO_TAGS[atr], attributes: attributes) if attr_value_zero?(value)
+          end
+        end
+
+        def attr_value_zero?(atr)
+          !atr.match?(/[1-9]/) && atr.match?(/\d/)
+        end
+
+        def mpadded_symbol
+          UnicodeMath::Constants::PHANTOM_SYMBOLS.key(options)
+        end
+
+        def mpadded_unicode
+          UnicodeMath::Constants::UNARY_SYMBOLS[mpadded_symbol]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Ms < UnaryFunction
+        def to_mathml_without_math_tag
+          Utility.ox_element("ms") << parameter_one
+        end
+
+        def to_asciimath
+          "\"“#{parameter_one}”\""
+        end
+
+        def to_latex
+          "\\text{“#{parameter_one}”}"
+        end
+
+        def to_omml_without_math_tag(display_style)
+          [
+            (Utility.ox_element("t", namespace: "m") << "“#{parameter_one}”"),
+          ]
+        end
+
+        def to_unicodemath
+          Text.new(parameter_one).to_unicodemath
+        end
+      end
+    end
+  end
+end

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

@@ -57,6 +57,10 @@ module Plurimath
           ]
         end
 
+        def to_unicodemath
+          parameter_one.map(&:to_unicodemath).join
+        end
+
         def line_breaking(obj)
           custom_array_line_breaking(obj)
         end

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

@@ -14,11 +14,9 @@ module Plurimath
           ox_element("msline")
         end
 
-        def to_omml_without_math_tag(display_style)
-          omml_value(display_style)
-        end
-
         def to_omml_without_math_tag(display_style);end
+
+        def to_unicodemath; end
       end
     end
   end

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