plurimath 0.5.0 → 0.7.0

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    module Function
+      class Nary < Core
+        attr_accessor :parameter_one, :parameter_two, :parameter_three, :parameter_four, :options
+
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       parameter_three = nil,
+                       parameter_four = nil,
+                       options = {})
+          @parameter_one = parameter_one
+          @parameter_two = parameter_two
+          @parameter_three = parameter_three
+          @parameter_four = parameter_four
+          @options = options
+          Utility.validate_left_right([parameter_one, parameter_two, parameter_three, parameter_four])
+        end
+
+        def ==(object)
+          self.class == object.class &&
+            object.parameter_one == parameter_one &&
+            object.parameter_two == parameter_two &&
+            object.parameter_three == parameter_three &&
+            object.parameter_four == parameter_four &&
+            object.options == options
+        end
+
+        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
+          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
+          "#{first_value}#{second_value}#{third_value}#{fourth_value}"
+        end
+
+        def to_mathml_without_math_tag
+          tag_name = options[:type] == "undOvr" ? "munderover" : "msubsup"
+          subsup_tag = ox_element(tag_name)
+          new_arr = [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_three),
+          ]
+          Utility.update_nodes(subsup_tag, new_arr)
+          return subsup_tag unless parameter_four
+
+          Utility.update_nodes(
+            ox_element("mrow"),
+            [
+              subsup_tag,
+              parameter_four&.to_mathml_without_math_tag,
+            ],
+          )
+        end
+
+        def to_omml_without_math_tag(display_style)
+          nary_element = Utility.ox_element("nary", namespace: "m")
+          Utility.update_nodes(nary_element, omml_nary_tag(display_style))
+          Array(nary_element)
+        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))
+            self.parameter_two = nil
+            self.parameter_three = nil
+            self.parameter_four = nil
+            return
+          end
+
+          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))
+            self.parameter_three = nil
+            self.parameter_four = nil
+            return
+          end
+
+          parameter_four&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(Utility.filter_values(obj.value))
+          end
+        end
+
+        protected
+
+        def chr_value(narypr)
+          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 })
+          hide_tags(narypr, parameter_two, "sub")
+          hide_tags(narypr, parameter_three, "sup")
+          narypr
+        end
+
+        def hide_tags(nar, field, tag_prefix)
+          return nar unless field.nil?
+
+          nar << Utility.ox_element("#{tag_prefix}Hide", namespace: "m", attributes: { "m:val": "1" })
+        end
+
+        def omml_nary_tag(display_style)
+          narypr = Utility.ox_element("naryPr", namespace: "m")
+          chr_value(narypr)
+          [
+            (narypr << Utility.pr_element("ctrl", true, namespace: "m")),
+            omml_parameter(parameter_two, display_style, tag_name: "sub"),
+            omml_parameter(parameter_three, display_style, tag_name: "sup"),
+            omml_parameter(parameter_four, display_style, tag_name: "e"),
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module Plurimath
   module Math
     module Function
       class Norm < UnaryFunction
+        attr_accessor :open_paren, :close_paren
+
         def to_asciimath
           parameter_one.is_a?(Table) ? "norm#{parameter_one.to_asciimath}" : super
         end
@@ -15,24 +17,31 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
-          norm = Utility.ox_element("mo") << "&#x2225;"
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            [
-              norm,
-              first_value,
-              norm,
-            ],
-          )
+          first_value = Array(parameter_one&.to_mathml_without_math_tag)
+          norm = ox_element("mo") << "&#x2225;"
+          first_value = first_value.insert(0, norm) unless open_paren
+          first_value = first_value << norm unless close_paren
+          Utility.update_nodes(ox_element("mrow"), first_value)
         end
 
         def to_omml_without_math_tag(display_style)
-          [
-            r_element("∥"),
-            omml_value(display_style),
-            r_element("∥"),
-          ]
+          array = []
+          array << r_element("∥") unless open_paren
+          array += Array(omml_value(display_style))
+          array << r_element("∥") unless close_paren
+          array
+        end
+
+        def line_breaking(obj)
+          parameter_one.line_breaking(obj)
+          if obj.value_exist?
+            norm_object = self.class.new(Utility.filter_values(obj.value))
+            norm_object.open_paren = true
+            norm_object.close_paren = false
+            obj.update(norm_object)
+            self.close_paren = true
+            self.open_paren = false unless open_paren
+          end
         end
       end
     end

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

@@ -53,6 +53,11 @@ module Plurimath
           end
         end
 
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
+
         protected
 
         def acc_tag(display_style)

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Oint < TernaryFunction
+        FUNCTION = {
+          name: "contour integral",
+          first_value: "subscript",
+          second_value: "supscript",
+        }
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -19,28 +25,33 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          mo_tag = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          mo_tag = ox_element("mo")
+          mo_tag << invert_unicode_symbols.to_s unless hide_function_name
           return mo_tag unless all_values_exist?
 
-          value_array = [mo_tag]
-          value_array << parameter_one&.to_mathml_without_math_tag
-          value_array << parameter_two&.to_mathml_without_math_tag
-          tag_name = if parameter_one && parameter_two
-                       "subsup"
-                     else
-                       parameter_one ? "sub" : "sup"
-                     end
-          msubsup_tag = Utility.ox_element("m#{tag_name}")
-          Utility.update_nodes(msubsup_tag, value_array)
-          return msubsup_tag if parameter_three.nil?
+          if parameter_one || parameter_two
+            value_array = [
+              mo_tag,
+              parameter_one&.to_mathml_without_math_tag,
+              parameter_two&.to_mathml_without_math_tag,
+            ]
+            tag_name = if parameter_one && parameter_two
+                         "subsup"
+                       else
+                         parameter_one ? "sub" : "sup"
+                       end
+            msubsup_tag = ox_element("m#{tag_name}")
+            Utility.update_nodes(msubsup_tag, value_array)
+            return msubsup_tag unless parameter_three
 
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            [
-              msubsup_tag,
-              parameter_three&.to_mathml_without_math_tag,
-            ].compact,
-          )
+            Utility.update_nodes(
+              ox_element("mrow"),
+              [
+                msubsup_tag,
+                parameter_three&.to_mathml_without_math_tag,
+              ],
+            )
+          end
         end
 
         def to_omml_without_math_tag(display_style)
@@ -49,7 +60,7 @@ module Plurimath
             Utility.update_nodes(
               nary,
               [
-                narypr("∮", function_type: "subSup"),
+                narypr((hide_function_name ? "" : "∮"), function_type: "subSup"),
                 omml_parameter(parameter_one, display_style, tag_name: "sub"),
                 omml_parameter(parameter_two, display_style, tag_name: "sup"),
                 omml_parameter(parameter_three, display_style, tag_name: "e"),
@@ -63,6 +74,23 @@ module Plurimath
             [r_tag]
           end
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            oint = self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            oint.hide_function_name = true
+            obj.update(oint)
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
+
+          parameter_three&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(Utility.filter_values(obj.value))
+          end
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Over < BinaryFunction
+        FUNCTION = {
+          name: "over",
+          first_value: "numerator",
+          second_value: "denominator",
+        }.freeze
+
         def to_asciimath
           first_value = wrapped(parameter_one)
           second_value = wrapped(parameter_two)
@@ -13,16 +19,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          mover_tag    = Utility.ox_element("mfrac")
-          first_value  = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          Utility.update_nodes(
-            mover_tag,
-            [
-              first_value,
-              second_value,
-            ],
-          )
+          tag_name = hide_function_name ? "mrow" : "mfrac"
+          mathml_value  = [
+            parameter_one&.to_mathml_without_math_tag,
+            parameter_two&.to_mathml_without_math_tag,
+          ]
+          Utility.update_nodes(ox_element(tag_name), mathml_value)
         end
 
         def to_latex
@@ -44,6 +46,23 @@ module Plurimath
           )
           [f_element]
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(Utility.filter_values(obj.value), parameter_two))
+            self.parameter_two = nil
+            self.hide_function_name = true
+            return
+          end
+
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            over = self.class.new(nil, Utility.filter_values(obj.value))
+            over.hide_function_name = true
+            obj.update(over)
+          end
+        end
       end
     end
   end

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

@@ -6,17 +6,18 @@ module Plurimath
   module Math
     module Function
       class Overset < BinaryFunction
+        FUNCTION = {
+          name: "overset",
+          first_value: "base",
+          second_value: "supscript",
+        }.freeze
+
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          over_tag = Utility.ox_element("mover")
-          Utility.update_nodes(
-            over_tag,
-            [
-              second_value,
-              first_value,
-            ],
-          )
+          value_array = [
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_one),
+          ]
+          Utility.update_nodes(ox_element("mover"), value_array)
         end
 
         def to_omml_without_math_tag(display_style)
@@ -38,6 +39,14 @@ module Plurimath
           )
           [limupp]
         end
+
+        def line_breaking(obj)
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(parameter_one, Utility.filter_values(obj.value)))
+            self.parameter_one = nil
+          end
+        end
       end
     end
   end

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

@@ -7,24 +7,42 @@ module Plurimath
     module Function
       class Phantom < UnaryFunction
         def to_asciimath
-          "#{Array.new(parameter_one&.length, '\ ').join}"
+          "#{Array.new(asciimath_value&.length, '\ ').join}"
         end
 
         def to_html
-          "<i>#{Array.new(parameter_one&.length, '&nbsp;').join}</i>"
+          "<i style='visibility: hidden;'>#{parameter_one&.to_html}</i>"
         end
 
         def to_latex
-          Array.new(parameter_one&.length, '\\ ').join
+          "\\#{class_name}{#{latex_value}}"
         end
 
         def to_mathml_without_math_tag
-          phantom = Utility.ox_element("mphantom")
           Utility.update_nodes(
-            phantom,
-            parameter_one&.map(&:to_mathml_without_math_tag),
+            Utility.ox_element("mphantom"),
+            Array(mathml_value),
           )
         end
+
+        def to_omml_without_math_tag(display_style)
+          phant = Utility.ox_element("phant", namespace: "m")
+          e_tag = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(e_tag, Array(omml_value(display_style)))
+          Utility.update_nodes(phant, [phant_pr, e_tag])
+        end
+
+        def line_breaking(obj)
+          custom_array_line_breaking(obj)
+        end
+
+        protected
+
+        def phant_pr
+          attributes = { val: "m:off" }
+          phant = Utility.ox_element("phant", namespace: "m")
+          phant << Utility.ox_element("show", namespace: "m", attributes: attributes)
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Power < BinaryFunction
+        FUNCTION = {
+          name: "superscript",
+          first_value: "base",
+          second_value: "script",
+        }.freeze
+
         def to_asciimath
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
           "#{parameter_one.to_asciimath}#{second_value}"
@@ -13,10 +19,11 @@ module Plurimath
 
         def to_mathml_without_math_tag
           tag_name = (["ubrace", "obrace"].include?(parameter_one&.class_name) ? "over" : "sup")
-          sup_tag = Utility.ox_element("m#{tag_name}")
-          mathml_value = [parameter_one.to_mathml_without_math_tag]
-          mathml_value << parameter_two&.to_mathml_without_math_tag
-          Utility.update_nodes(sup_tag, mathml_value)
+          value_array = [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+          ]
+          Utility.update_nodes(ox_element("m#{tag_name}"), value_array)
         end
 
         def to_latex
@@ -45,6 +52,14 @@ module Plurimath
           )
           [ssup_element]
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(Utility.filter_values(obj.value), parameter_two))
+            self.parameter_two = nil
+          end
+        end
       end
     end
   end

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

@@ -6,12 +6,21 @@ module Plurimath
   module Math
     module Function
       class PowerBase < TernaryFunction
+        FUNCTION = {
+          name: "subsup",
+          first_value: "base",
+          second_value: "subscript",
+          third_value: "supscript",
+        }.freeze
+
         def to_mathml_without_math_tag
-          subsup_tag = Utility.ox_element("m#{parameter_one.tag_name}")
-          new_arr = []
-          new_arr << parameter_one.to_mathml_without_math_tag
-          new_arr << parameter_two&.to_mathml_without_math_tag
-          new_arr << parameter_three&.to_mathml_without_math_tag
+          tag_name = parameter_one&.tag_name || "subsup"
+          subsup_tag = ox_element("m#{tag_name}")
+          new_arr = [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_three),
+          ]
           Utility.update_nodes(subsup_tag, new_arr)
         end
 
@@ -29,25 +38,8 @@ module Plurimath
           "#{first_value}#{second_value}#{third_value}"
         end
 
-        def omml_nary_tag(display_style)
-          narypr = Utility.ox_element("naryPr", namespace: "m")
-          chr_value(narypr)
-          narypr << Utility.ox_element(
-            "limLoc",
-            namespace: "m",
-            attributes: { "m:val": parameter_one.omml_tag_name },
-          )
-          hide_tags(narypr)
-          narypr << Utility.pr_element("ctrl", true, namespace: "m")
-          [
-            narypr,
-            omml_parameter(parameter_two, display_style, tag_name: "sub"),
-            omml_parameter(parameter_three, display_style, tag_name: "sup"),
-          ]
-        end
-
         def to_omml_without_math_tag(display_style)
-          return underover(display_style) if parameter_one.omml_tag_name == "undOvr"
+          return underover(display_style) if parameter_one&.omml_tag_name == "undOvr"
 
           ssubsup   = Utility.ox_element("sSubSup", namespace: "m")
           ssubsuppr = Utility.ox_element("sSubSupPr", namespace: "m")
@@ -66,19 +58,28 @@ module Plurimath
           [ssubsup]
         end
 
-        protected
-
-        def chr_value(narypr)
-          first_value = Utility.html_entity_to_unicode(parameter_one&.nary_attr_value)
-          return narypr if first_value == "∫"
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            )
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
 
-          narypr << Utility.ox_element(
-            "chr",
-            namespace: "m",
-            attributes: { "m:val": first_value },
-          )
+          parameter_two.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              self.class.new(nil, Utility.filter_values(obj.value), parameter_three)
+            )
+            self.parameter_three = nil
+          end
         end
 
+        protected
+
         def hide_tags(nar)
           attr = { "m:val": "1" }
           if parameter_two.nil?

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Prod < TernaryFunction
+        FUNCTION = {
+          name: "prod",
+          first_value: "subscript",
+          second_value: "supscript",
+        }.freeze
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -19,17 +25,20 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          first_value = ox_element("mo")
+          first_value << invert_unicode_symbols.to_s unless hide_function_name
           if parameter_one || parameter_two
-            value_array = [first_value]
-            value_array << parameter_one&.to_mathml_without_math_tag
-            value_array << 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}")
+            value_array = [
+              first_value,
+              parameter_one&.to_mathml_without_math_tag,
+              parameter_two&.to_mathml_without_math_tag,
+            ]
+            munderover_tag = ox_element("m#{tag_name}")
             Utility.update_nodes(
               munderover_tag,
               value_array,
@@ -55,29 +64,40 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          if all_values_exist?
-            nary = Utility.ox_element("nary", namespace: "m")
-            Utility.update_nodes(
-              nary,
-              [
-                narypr("∏"),
-                omml_parameter(parameter_one, display_style, tag_name: "sub"),
-                omml_parameter(parameter_two, display_style, tag_name: "sup"),
-                omml_parameter(parameter_three, display_style, tag_name: "e"),
-              ],
-            )
-            [nary]
-          else
-            r_tag = Utility.ox_element("r", namespace: "m")
-            t_tag = Utility.ox_element("t", namespace: "m")
-            r_tag << (t_tag << "&#x220f;")
-            [r_tag]
-          end
+          return r_element("&#x220f;", rpr_tag: false) unless all_values_exist?
+
+          nary = Utility.ox_element("nary", namespace: "m")
+          Utility.update_nodes(nary, nary_values(display_style))
+          [nary]
+        end
+
+        def nary_values(display_style)
+          [
+            narypr(hide_function_name ? "" : nary_attr_value),
+            omml_parameter(parameter_one, display_style, tag_name: "sub"),
+            omml_parameter(parameter_two, display_style, tag_name: "sup"),
+            omml_parameter(parameter_three, display_style, tag_name: "e"),
+          ]
         end
 
         def nary_attr_value
           "∏"
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            prod = self.class.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            prod.hide_function_name = true
+            obj.update(prod)
+            return
+          end
+
+          parameter_three&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(Utility.filter_values(obj.value))
+          end
+        end
       end
     end
   end