plurimath 0.7.2 → 0.8.1

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Int < TernaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "integral",
           first_value: "lower limit",
           second_value: "upper limit",
           third_value: "integrand"
-        }
+        }.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
@@ -62,6 +75,13 @@ module Plurimath
           end
         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)
+          "∫#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three)}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -88,6 +108,32 @@ module Plurimath
             omml_parameter(parameter_three, display_style, tag_name: "e"),
           ]
         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/intent.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Intent < BinaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one.to_mathml_without_math_tag
+          first_value.attributes[:intent] = Utility.html_entity_to_unicode(parameter_two.value)
+          first_value
+        end
+
+        def to_unicodemath
+          first_value = "(#{parameter_two.to_unicodemath}#{parameter_one.to_unicodemath})" if parameter_one || parameter_two
+          "ⓘ#{first_value}"
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -49,6 +49,12 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          first_value  = "_#{unicodemath_parens(parameter_one)}" if parameter_one
+          second_value = "^#{unicodemath_parens(parameter_two)}" if parameter_two
+          "lim#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -34,6 +34,10 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          "#{parameter_one&.to_unicodemath}#{sup_value}#{sub_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -49,6 +53,30 @@ module Plurimath
             self.parameter_three = nil
           end
         end
+
+        protected
+
+        def sup_value
+          return unless parameter_three
+
+          if 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
+          return unless parameter_two
+
+          if parameter_two.is_a?(Math::Function::Base)
+            "┬#{parameter_two.to_unicodemath}"
+          else
+            "┬#{unicodemath_parens(parameter_two)}"
+          end
+        end
       end
     end
   end

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

@@ -82,6 +82,11 @@ module Plurimath
           result
         end
 
+        def to_unicodemath
+          first_value = parameter_one.to_unicodemath if parameter_one
+          "
#{first_value}"
+        end
+
         def separate_table
           true
         end

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

@@ -35,7 +35,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,
             [
@@ -63,6 +63,12 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          first_value = sub_value if parameter_one
+          second_value = sup_value if parameter_two
+          "log#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -82,25 +88,6 @@ module Plurimath
           e_tag << rpr_tag
         end
 
-        def hide_tags(nar)
-          attr = { "m:val": "1" }
-          if parameter_one.nil?
-            nar << Utility.ox_element(
-              "subHide",
-              namespace: "m",
-              attributes: attr,
-            )
-          end
-          if parameter_two.nil?
-            nar << Utility.ox_element(
-              "supHide",
-              namespace: "m",
-              attributes: attr,
-            )
-          end
-          nar
-        end
-
         def rpr_tag
           sty_atrs = { "m:val": "p" }
           sty_tag  = Utility.ox_element("sty", attributes: sty_atrs, namespace: "m")
@@ -109,6 +96,26 @@ module Plurimath
           t_tag = (Utility.ox_element("t", namespace: "m") << "log")
           Utility.update_nodes(r_tag, [rpr_tag, t_tag])
         end
+
+        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/longdiv.rb

@@ -25,6 +25,10 @@ module Plurimath
           omml_value(display_style)
         end
 
+        def to_unicodemath
+          parameter_one&.to_unicodemath
+        end
+
         def line_breaking(obj)
           custom_array_line_breaking(obj)
         end

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

@@ -24,6 +24,10 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           Text.new(parameter_one).to_omml_without_math_tag(display_style)
         end
+
+        def to_unicodemath
+          Text.new(parameter_one).to_unicodemath
+        end
       end
     end
   end

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

@@ -11,6 +11,18 @@ module Plurimath
           first_value: "enclosure type",
           second_value: "expression",
         }.freeze
+        FOUR_SIDED_NOTATIONS = {
+          top: "hideTop",
+          bottom: "hideBot",
+          left: "hideLeft",
+          right: "hideRight",
+        }
+        STRIKES_NOTATIONS = {
+          horizontalstrike: "strikeH",
+          verticalstrike: "strikeV",
+          updiagonalstrike: "strikeBLTR",
+          downdiagonalstrike: "strikeTLBR",
+        }
 
         def to_asciimath
           parameter_two&.to_asciimath
@@ -18,7 +30,7 @@ module Plurimath
 
         def to_mathml_without_math_tag
           attributes = { notation: parameter_one }
-          menclose = Utility.ox_element("menclose", attributes: attributes)
+          menclose = ox_element("menclose", attributes: attributes)
           menclose << parameter_two.to_mathml_without_math_tag if parameter_two
           menclose
         end
@@ -33,18 +45,75 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          borderbox = Utility.ox_element("borderBox", namespace: "m")
-          borderpr = Utility.ox_element("borderBoxPr", namespace: "m")
-          borderpr << Utility.pr_element("ctrl", true, namespace: "m")
+          borderbox = ox_element("borderBox", namespace: "m")
           Utility.update_nodes(
             borderbox,
             [
-              borderpr,
+              borderboxpr,
               omml_parameter(parameter_two, display_style, tag_name: "e"),
             ],
           )
           [borderbox]
         end
+
+        def to_unicodemath
+          if unicode_symbol?
+            "#{unicode_symbol}#{unicodemath_parens(parameter_two)}"
+          elsif masked_class?
+            first_value = Utility.notations_to_mask(parameter_one) if parameter_one
+            second_value = parameter_two&.to_unicodemath if parameter_two
+            "▭(#{first_value}&#{second_value})"
+          end
+        end
+
+        protected
+
+        def borderboxpr
+          return if %w[box circle roundedbox].include?(parameter_one)
+
+          borderpr = ox_element("borderBoxPr", namespace: "m")
+          four_sided_notations(borderpr)
+          strikes_notations(borderpr)
+          borderpr
+        end
+
+        def four_sided_notations(borderpr)
+          return if %w[box circle roundedbox].any? { |value| parameter_one.include?(value) }
+
+          FOUR_SIDED_NOTATIONS.each do |side, rep|
+            border_ox_element(rep, !parameter_one.include?(side.to_s), borderpr)
+          end
+        end
+
+        def strikes_notations(borderpr)
+          STRIKES_NOTATIONS.each do |strike, rep|
+            border_ox_element(rep, parameter_one.include?(strike.to_s), borderpr)
+          end
+        end
+
+        def border_ox_element(tag_name, condition, borderpr)
+          return unless condition
+
+          borderpr << ox_element(
+            tag_name,
+            namespace: "m",
+            attributes: { "m:val": "on" },
+          )
+        end
+
+        def masked_class?
+          Utility::MASK_CLASSES.values.any? { |mask| parameter_one.include?(mask) }
+        end
+
+        def unicode_symbol
+          class_name = Utility::UNICODEMATH_MENCLOSE_FUNCTIONS.key(parameter_one)
+          UnicodeMath::Constants::UNARY_ARG_FUNCTIONS[class_name] ||
+            UnicodeMath::Constants::UNARY_SYMBOLS[class_name]
+        end
+
+        def unicode_symbol?
+          Utility::UNICODEMATH_MENCLOSE_FUNCTIONS.value?(parameter_one)
+        end
       end
     end
   end

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

@@ -16,6 +16,8 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(_); end
+
+        def to_unicodemath; end
       end
     end
   end

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