plurimath 0.2.0 → 0.2.2

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Menclose < BinaryFunction
+        def to_asciimath
+          parameter_two&.to_asciimath
+        end
+
+        def to_mathml_without_math_tag
+          attributes = { notation: parameter_one }
+          menclose = Utility.ox_element("menclose", attributes: attributes)
+          menclose << parameter_two.to_mathml_without_math_tag if parameter_two
+          menclose
+        end
+
+        def to_latex
+          parameter_two&.to_latex
+        end
+
+        def to_html
+          second_value = parameter_two&.to_html
+          "<menclose notation=\"#{parameter_one}\">#{second_value}</menclose>"
+        end
+
+        def to_omml_without_math_tag
+          borderbox = Utility.ox_element("borderBox", namespace: "m")
+          borderpr = Utility.ox_element("borderBoxPr", namespace: "m")
+          borderpr << Utility.pr_element("ctrl", true, namespace: "m")
+          me = Utility.ox_element("e", namespace: "m")
+          me << parameter_two.to_omml_without_math_tag if parameter_two
+          Utility.update_nodes(
+            borderbox,
+            [
+              borderpr,
+              me,
+            ],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Merror < BinaryFunction
+      end
+    end
+  end
+end

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

@@ -7,15 +7,36 @@ module Plurimath
     module Function
       class Mod < BinaryFunction
         def to_asciimath
-          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
-          second_value = "(#{parameter_two.to_asciimath})" if parameter_two
-          "#{first_value}mod#{second_value}"
+          first_value = parameter_one&.to_asciimath
+          second_value = parameter_two&.to_asciimath
+          "#{first_value} mod #{second_value}"
+        end
+
+        def to_mathml_without_math_tag
+          mrow_tag = Utility.ox_element("mrow")
+          mo_tag = Utility.ox_element("mi") << "mod"
+          first_value = parameter_one&.to_mathml_without_math_tag if parameter_one
+          second_value = parameter_two&.to_mathml_without_math_tag if parameter_two
+          Utility.update_nodes(
+            mrow_tag,
+            [
+              first_value,
+              mo_tag,
+              second_value,
+            ],
+          )
         end
 
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           second_value = "{#{parameter_two.to_latex}}" if parameter_two
-          "#{first_value}\\pmod#{second_value}"
+          "#{first_value} \\mod #{second_value}"
+        end
+
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          second_value = "<i>#{parameter_two.to_html}</i>" if parameter_two
+          "#{first_value}<i>mod</i>#{second_value}"
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Msgroup < UnaryFunction
+        def to_asciimath
+          parameter_one.map(&:to_asciimath).join
+        end
+
+        def to_latex
+          parameter_one.map(&:to_latex).join
+        end
+
+        def to_mathml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("msgroup"),
+            parameter_one.map(&:to_mathml_without_math_tag),
+          )
+        end
+
+        def to_omml_without_math_tag
+          Utility.update_nodes(
+            Utility.ox_element("msgroup"),
+            parameter_one&.map(&:to_omml_without_math_tag),
+          )
+        end
+
+        def to_html
+          "<i>#{parameter_one.map(&:to_html).join}</i>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Msline < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "ternary_function"
+module Plurimath
+  module Math
+    module Function
+      class Multiscript < TernaryFunction
+        def to_omml_without_math_tag
+          pre_element = Utility.ox_element("sPre", namespace: "m")
+          pr_element  = Utility.ox_element("sPrePr", namespace: "m")
+          sub_element = Utility.ox_element("sub", namespace: "m")
+          sub_element << parameter_two.to_omml_without_math_tag if parameter_two
+          sup_element = Utility.ox_element("sup", namespace: "m")
+          sup_element << parameter_three.to_omml_without_math_tag if parameter_three
+          e_element   = Utility.ox_element("e", namespace: "m")
+          e_element  << parameter_one.to_omml_without_math_tag if parameter_one
+          Utility.update_nodes(
+            pre_element,
+            [
+              pr_element << Utility.pr_element("ctrl", true, namespace: "m"),
+              sub_element,
+              sup_element,
+              e_element,
+            ],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,25 @@ module Plurimath
   module Math
     module Function
       class Norm < UnaryFunction
+        def to_asciimath
+          parameter_one.is_a?(Table) ? "norm#{parameter_one.to_asciimath}" : super
+        end
+
+        def to_latex
+          "{\\lVert #{parameter_one&.to_latex} \\lVert}"
+        end
+
         def to_mathml_without_math_tag
-          "<mo>&#x2225;</mo>#{parameter_one.to_mathml_without_math_tag}<mo>&#x2225;</mo>"
+          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,
+            ],
+          )
         end
       end
     end

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

@@ -6,7 +6,24 @@ module Plurimath
   module Math
     module Function
       class Obrace < UnaryFunction
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          "\\overbrace#{first_value}"
+        end
+
+        def to_mathml_without_math_tag
+          mo_tag = (Utility.ox_element("mo") << "&#x23de;")
+          if parameter_one
+            over_tag = Utility.ox_element("mover")
+            arr_value = mathml_value
+            Utility.update_nodes(over_tag, (arr_value << mo_tag))
+          else
+            mo_tag
+          end
+        end
       end
+
+      Overbrace = Obrace
     end
   end
 end

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

@@ -7,8 +7,8 @@ module Plurimath
     module Function
       class Oint < BinaryFunction
         def to_asciimath
-          first_value = "_(#{parameter_one.to_asciimath})" if parameter_one
-          second_value = "^(#{parameter_two.to_asciimath})" if parameter_two
+          first_value = "_#{wrapped(parameter_one)}" if parameter_one
+          second_value = "^#{wrapped(parameter_two)}" if parameter_two
           "oint#{first_value}#{second_value}"
         end
       end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Over < BinaryFunction
+        def to_asciimath
+          first_value = wrapped(parameter_one)
+          second_value = wrapped(parameter_two)
+          "overset#{first_value}#{second_value}"
+        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,
+            ],
+          )
+        end
+
+        def to_latex
+          first_value = parameter_one&.to_latex
+          two_value = parameter_two&.to_latex
+          "{#{first_value} \\over #{two_value}}"
+        end
+      end
+    end
+  end
+end

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

@@ -7,15 +7,44 @@ module Plurimath
     module Function
       class Overset < BinaryFunction
         def to_mathml_without_math_tag
-          first_value = parameter_one.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
-          "<mover>#{second_value}#{first_value}</mover>"
+          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,
+            ],
+          )
         end
 
-        def to_latex
-          first_value = "{#{parameter_one.to_latex}" if parameter_one
-          second_value = "#{parameter_two.to_latex}}" if parameter_two
-          "#{first_value}\\over#{second_value}"
+        def to_omml_without_math_tag
+          first_value  = if parameter_one.is_a?(Math::Symbol)
+                           mt = Utility.ox_element("t", namespace: "m")
+                           mt << parameter_one.to_omml_without_math_tag
+                         else
+                           parameter_one.to_omml_without_math_tag
+                         end
+          second_value = if parameter_two.is_a?(Math::Symbol)
+                           mt = Utility.ox_element("t", namespace: "m")
+                           mt << parameter_two.to_omml_without_math_tag
+                         else
+                           parameter_two.to_omml_without_math_tag
+                         end
+          limupp   = Utility.ox_element("limUpp", namespace: "m")
+          limupppr = Utility.ox_element("limUppPr", namespace: "m")
+          limupppr << Utility.pr_element("ctrl", true, namespace: "m")
+          me = (Utility.ox_element("e", namespace: "m") << first_value)
+          lim = (Utility.ox_element("lim", namespace: "m") << second_value)
+          Utility.update_nodes(
+            limupp,
+            [
+              limupppr,
+              me,
+              lim,
+            ],
+          )
         end
       end
     end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Phantom < UnaryFunction
+        def to_asciimath
+          "\"#{Array.new(parameter_one&.length, ' ').join}\""
+        end
+
+        def to_html
+          "<i>#{Array.new(parameter_one&.length, '&nbsp;').join}</i>"
+        end
+
+        def to_latex
+          "<i>#{Array.new(parameter_one&.length, '\\ ').join}</i>"
+        end
+
+        def to_mathml_without_math_tag
+          mi_tag_value = Array.new(parameter_one&.length, "&nbsp;&nbsp;").join
+          Utility.ox_element("mi") << mi_tag_value
+        end
+      end
+    end
+  end
+end

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

@@ -7,23 +7,47 @@ module Plurimath
     module Function
       class Power < BinaryFunction
         def to_asciimath
-          first_value = parameter_one.to_asciimath if parameter_one
-          second_value = "^#{parameter_two.to_asciimath}" if parameter_two
-          "#{first_value}#{second_value}"
+          second_value = "^#{wrapped(parameter_two)}" if parameter_two
+          "#{parameter_one.to_asciimath}#{second_value}"
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one.to_mathml_without_math_tag
-          second_value = parameter_two.to_mathml_without_math_tag
-          "<msup>#{first_value}#{second_value}</msup>"
+          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)
         end
 
         def to_latex
-          first_value = parameter_one.to_latex if parameter_one
-          first_value  = "{#{first_value}}" if parameter_one.is_a?(Math::Formula)
-          second_value = parameter_two.to_latex
+          first_value  = parameter_one.to_latex
+          second_value = parameter_two.to_latex if parameter_two
           "#{first_value}^{#{second_value}}"
         end
+
+        def to_html
+          first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          second_value = "<sup>#{parameter_two.to_html}</sup>" if parameter_two
+          "#{first_value}#{second_value}"
+        end
+
+        def to_omml_without_math_tag
+          ssup_element  = Utility.ox_element("sSup", namespace: "m")
+          suppr_element = Utility.ox_element("sSupPr", namespace: "m")
+          sup_element   = Utility.ox_element("sup", namespace: "m")
+          e_element     = Utility.ox_element("e", namespace: "m")
+          e_element << parameter_one.to_omml_without_math_tag if parameter_one
+          sup_element << parameter_two.to_omml_without_math_tag if parameter_two
+          Utility.update_nodes(
+            ssup_element,
+            [
+              suppr_element << Utility.pr_element("ctrl", true, namespace: "m"),
+              e_element,
+              sup_element,
+            ],
+          )
+          ssup_element
+        end
       end
     end
   end

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

@@ -7,19 +7,124 @@ module Plurimath
     module Function
       class PowerBase < TernaryFunction
         def to_mathml_without_math_tag
-          first_value  = parameter_one.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
-          third_value  = parameter_three.to_mathml_without_math_tag if parameter_three
-          "<msubsup>#{first_value}#{second_value}#{third_value}</msubsup>"
+          tag_name = (["ubrace", "obrace"].include?(parameter_one&.class_name) ? "underover" : "subsup")
+          subsup_tag = Utility.ox_element("m#{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
+          Utility.update_nodes(
+            subsup_tag,
+            new_arr,
+          )
         end
 
         def to_latex
           first_value  = parameter_one.to_latex if parameter_one
           second_value = parameter_two.to_latex if parameter_two
           third_value  = parameter_three.to_latex if parameter_three
-          first_value  = "{#{first_value}}" if parameter_one.is_a?(Math::Formula)
           "#{first_value}_{#{second_value}}^{#{third_value}}"
         end
+
+        def to_html
+          first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          second_value = "<sub>#{parameter_two.to_html}</sub>" if parameter_two
+          third_value  = "<sup>#{parameter_three.to_html}</sup>" if parameter_three
+          "#{first_value}#{second_value}#{third_value}"
+        end
+
+        def omml_nary_tag
+          narypr = Utility.ox_element("naryPr", namespace: "m")
+          chr_value(narypr)
+          narypr << Utility.ox_element(
+            "limLoc",
+            namespace: "m",
+            attributes: { "m:val": "subSup" },
+          )
+          hide_tags(narypr)
+          narypr << Utility.pr_element("ctrl", true, namespace: "m")
+          [
+            narypr,
+            sub_element,
+            sup_element,
+          ]
+        end
+
+        def to_omml_without_math_tag
+          ssubsup   = Utility.ox_element("sSubSup", namespace: "m")
+          ssubsuppr = Utility.ox_element("sSubSupPr", namespace: "m")
+          ssubsuppr << hide_tags(
+            Utility.pr_element("ctrl", true, namespace: "m"),
+          )
+          Utility.update_nodes(
+            ssubsup,
+            [
+              ssubsuppr,
+              e_element,
+              sub_element,
+              sup_element,
+            ],
+          )
+        end
+
+        protected
+
+        def chr_value(narypr)
+          first_value = parameter_one.to_omml_without_math_tag
+          return narypr if first_value == "∫"
+
+          narypr << Utility.ox_element(
+            "chr",
+            namespace: "m",
+            attributes: { "m:val": first_value },
+          )
+        end
+
+        def e_element
+          elemnet = Utility.ox_element("e", namespace: "m")
+          if parameter_one
+            elemnet << parameter_one&.to_omml_without_math_tag
+          else
+            elemnet
+          end
+        end
+
+        def sub_element
+          elemnet = Utility.ox_element("sub", namespace: "m")
+          if parameter_two
+            elemnet << parameter_two&.to_omml_without_math_tag
+          else
+            elemnet
+          end
+        end
+
+        def sup_element
+          elemnet = Utility.ox_element("sup", namespace: "m")
+          if parameter_three
+            elemnet << parameter_three&.to_omml_without_math_tag
+          else
+            elemnet
+          end
+        end
+
+        def hide_tags(nar)
+          attr = { "m:val": "1" }
+          if parameter_two.nil?
+            nar << Utility.ox_element(
+              "subHide",
+              namespace: "m",
+              attributes: attr,
+            )
+          end
+          if parameter_three.nil?
+            nar << Utility.ox_element(
+              "supHide",
+              namespace: "m",
+              attributes: attr,
+            )
+          end
+          nar
+        end
       end
     end
   end

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

@@ -7,8 +7,8 @@ module Plurimath
     module Function
       class Prod < BinaryFunction
         def to_asciimath
-          first_value = "_(#{parameter_one.to_asciimath})" if parameter_one
-          second_value = "^(#{parameter_two.to_asciimath})" if parameter_two
+          first_value = "_#{wrapped(parameter_one)}" if parameter_one
+          second_value = "^#{wrapped(parameter_two)}" if parameter_two
           "prod#{first_value}#{second_value}"
         end
 
@@ -17,6 +17,33 @@ module Plurimath
           second_value = "^{#{parameter_two.to_latex}}" if parameter_two
           "\\prod#{first_value}#{second_value}"
         end
+
+        def to_mathml_without_math_tag
+          first_value = Utility.ox_element("mo") << invert_unicode_symbols.to_s
+          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}")
+            Utility.update_nodes(
+              munderover_tag,
+              value_array,
+            )
+          else
+            first_value
+          end
+        end
+
+        def to_html
+          first_value = "<sub>#{parameter_one.to_html}</sub>" if parameter_one
+          second_value = "<sup>#{parameter_two.to_html}</sup>" if parameter_two
+          "<i>&prod;</i>#{first_value}#{second_value}"
+        end
       end
     end
   end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Right < UnaryFunction
+        def to_asciimath
+          "right#{parameter_one}"
+        end
+
+        def to_mathml_without_math_tag
+          mo = Utility.ox_element("mo")
+          mo << right_paren if parameter_one
+          mo
+        end
+
+        def to_omml_without_math_tag
+          mt = Utility.ox_element("m:t")
+          mt << parameter_one if parameter_one
+          mt
+        end
+
+        def to_html
+          "<i>#{parameter_one}</i>"
+        end
+
+        def to_latex
+          prefix = "\\" if parameter_one == "}"
+          "\\right #{prefix}#{parameter_one}"
+        end
+
+        protected
+
+        def right_paren
+          return "}" if parameter_one == "\\}"
+
+          parameter_one
+        end
+      end
+    end
+  end
+end