plurimath 0.7.2 → 0.8.1

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

@@ -53,6 +53,10 @@ module Plurimath
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̅"
+        end
+
         protected
 
         def acc_tag(display_style)

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Base < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "subscript",
           first_value: "base",
           second_value: "script",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value = parameter_one.to_asciimath if parameter_one
           second_value = "_#{wrapped(parameter_two)}" if parameter_two
@@ -55,6 +68,20 @@ module Plurimath
           [ssub_element]
         end
 
+        def to_unicodemath
+          first_value = parameter_one.to_unicodemath if parameter_one
+          second_value = if parameter_two.is_a?(self.class)
+            "_#{size_overrides}#{parameter_two.to_unicodemath}"
+          elsif parameter_two&.mini_sized?
+            parameter_two.to_unicodemath
+          elsif parameter_two.nil?
+            "()"
+          else
+            "_#{size_overrides}#{unicodemath_parens(parameter_two)}"
+          end
+          "#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -68,6 +95,28 @@ module Plurimath
             obj.update(self.class.new(nil, Utility.filter_values(obj.value)))
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, parameter_two, nil, fourth_value)
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        end
+
+        protected
+
+        def size_overrides
+          return if options.nil? || options&.empty?
+
+          "Ⅎ#{UnicodeMath::Constants::SIZE_OVERRIDES_SYMBOLS.invert[options[:size]]}" if options[:size]
+        end
+
+        def unicodemath_parens(field)
+          return "〖#{field.to_unicodemath}〗" unless options.nil? || options&.empty?
+
+          super(field)
+        end
       end
     end
   end

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

@@ -131,6 +131,12 @@ module Plurimath
           underset = Underset.new(overset, parameter_one)
           Array(underset.to_omml_without_math_tag(display_style))
         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
       end
     end
   end

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

@@ -18,6 +18,11 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           omml_value(display_style)
         end
+
+        def to_unicodemath
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          "╱#{first_value}"
+        end
       end
     end
   end

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

@@ -31,6 +31,12 @@ module Plurimath
           "<i>&#x2308;</i>#{first_value}<i>&#x2309;</i>"
         end
 
+        def to_unicodemath
+          first_value = "&#x2308;" unless open_paren
+          second_value = "&#x2309;" unless close_paren
+          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -6,12 +6,20 @@ module Plurimath
   module Math
     module Function
       class Color < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "color",
           first_value: "mathcolor",
           second_value: "text",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath&.gsub(/\s/, '')})"
           second_value = "(#{parameter_two&.to_asciimath})"
@@ -19,10 +27,11 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
+          color_value = parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "")
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
-              attributes: { mathcolor: parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "") },
+              attributes: { attr_key => color_value },
             ),
             [parameter_two&.to_mathml_without_math_tag],
           )
@@ -45,6 +54,16 @@ module Plurimath
           omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: "text", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
           new_arr
         end
+
+        def to_unicodemath
+          "✎(#{parameter_one.to_unicodemath}&#{parameter_two.to_unicodemath})"
+        end
+
+        protected
+
+        def attr_key
+          (options && options[:backcolor]) ? :mathbackground : :mathcolor
+        end
       end
     end
   end

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

@@ -33,6 +33,10 @@ module Plurimath
           "#{first_value}<i>..</i>"
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̈"
+        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/dot.rb

@@ -41,6 +41,11 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          "#{first_value}̇"
+        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/fenced.rb

@@ -6,6 +6,22 @@ module Plurimath
   module Math
     module Function
       class Fenced < TernaryFunction
+        attr_accessor :options
+
+        def initialize(
+              parameter_one = nil,
+              parameter_two = nil,
+              parameter_three = nil,
+              options = {})
+          super(parameter_one, parameter_two, parameter_three)
+          @options = options
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value  = parameter_one ? parameter_one.to_asciimath : "("
           third_value  = parameter_three ? parameter_three.to_asciimath : ")"
@@ -13,9 +29,9 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = Utility.ox_element("mo") << (mathml_paren(parameter_one) || "")
+          first_value = Utility.ox_element("mo", attributes: options&.dig(:open_paren)) << (mathml_paren(parameter_one) || "")
           second_value = parameter_two&.map(&:to_mathml_without_math_tag) || []
-          third_value = Utility.ox_element("mo") << (mathml_paren(parameter_three) || "")
+          third_value = Utility.ox_element("mo", attributes: options&.dig(:close_paren)) << (mathml_paren(parameter_three) || "")
           Utility.update_nodes(
             Utility.ox_element("mrow"),
             (second_value.insert(0, first_value) << third_value),
@@ -37,17 +53,41 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
+          attrs = { "m:val": (options ? options[:separators] : "") }
           d = Utility.ox_element("d", namespace: "m")
           dpr = Utility.ox_element("dPr", namespace: "m")
-          parameter = Formula.new(Array(parameter_two))
           open_paren(dpr)
+          dpr << Utility.ox_element("sepChr", namespace: "m", attributes: attrs)
           close_paren(dpr)
-          fenced_value = omml_parameter(parameter, display_style, tag_name: "e")
-          dpr << Utility.pr_element("ctrl", true, namespace: "m")
-          Utility.update_nodes(d, [dpr, fenced_value])
+          Utility.update_nodes(
+            d,
+            [
+              dpr,
+              omml_parameter(
+                Formula.new(Array(parameter_two)),
+                display_style,
+                tag_name: "e",
+              ),
+            ],
+          )
           [d]
         end
 
+        def to_unicodemath
+          return mini_sized_unicode if mini_sized?
+
+          fenced_value = parameter_two&.map do |param|
+            next param.choose_frac if choose_frac?(param)
+
+            param.to_unicodemath
+          end&.join(" ")
+          return fenced_value if choose_frac?(parameter_two.first)
+
+          fenced_value = "(#{fenced_value})" if parameter_one&.value&.include?("|")
+
+          "#{unicode_open_paren}#{fenced_value}#{unicode_close_paren}"
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           filtered_values(parameter_two).map.with_index(1) do |object, index|
             last = index == @values.length
@@ -82,6 +122,17 @@ module Plurimath
           obj.update(value_split(obj, field_values))
         end
 
+        def mini_sized?
+          parameter_one&.mini_sized? ||
+            Math::Formula.new(parameter_two)&.mini_sized? ||
+            parameter_three&.mini_sized?
+        end
+
+        def mini_sized_unicode
+          fenced_value = parameter_two&.map(&:to_unicodemath)&.join
+          "#{parameter_one.to_unicodemath}#{fenced_value}#{parameter_three.to_unicodemath}"
+        end
+
         protected
 
         def open_paren(dpr)
@@ -118,7 +169,8 @@ module Plurimath
         end
 
         def mathml_paren(field)
-          return "" if field&.value&.include?(":")
+          unicodemath_syntax = ["&#x3016;", "&#x3017;", "&#x2524;", "&#x251c;"]
+          return "" if field&.value&.include?(":") || unicodemath_syntax.include?(field&.value&.to_s)
 
           field&.value
         end
@@ -132,6 +184,45 @@ module Plurimath
           self.parameter_three = nil
           object
         end
+
+        def unicode_open_paren
+          paren = parameter_one&.to_unicodemath
+          return "├#{convert_paren_size(paren_size: options&.dig(:open_paren, :minsize))}#{paren}" if options&.key?(:open_paren)
+          return "├#{paren}" if options&.key?(:open_prefixed) && !open_or_begin?
+          return "├" if options&.key?(:open_prefixed) || paren == "{:"
+
+          paren
+        end
+
+        def unicode_close_paren
+          paren = parameter_three&.to_unicodemath
+          return "┤#{convert_paren_size(paren_size: options&.dig(:close_paren, :minsize))}#{paren}" if options&.key?(:close_paren)
+          return "┤#{paren}" if options&.key?(:close_prefixed) && !close_or_end?
+          return "┤" if options&.key?(:close_prefixed) || paren == ":}"
+
+          paren
+        end
+
+        def choose_frac?(param)
+          param&.is_a?(Math::Function::Frac) && param&.options&.key?(:choose)
+        end
+
+        def convert_paren_size(paren_size:)
+          paren = paren_size.delete_suffix("em").to_f
+          (::Math.log(paren) / ::Math.log(1.25)).round
+        end
+
+        def open_or_begin?
+          parameter_one&.value&.include?("&#x251c;") ||
+            parameter_one&.value&.include?("&#x3016;") ||
+            parameter_one&.value&.include?("{:")
+        end
+
+        def close_or_end?
+          parameter_three&.value&.include?("&#x2524;") ||
+            parameter_three&.value&.include?("&#x3017;") ||
+            parameter_three&.value&.include?(":}")
+        end
       end
     end
   end

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

@@ -28,6 +28,12 @@ module Plurimath
           array
         end
 
+        def to_unicodemath
+          first_value = "⌊" unless open_paren
+          second_value = "⌋" unless close_paren
+          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

data/lib/plurimath/math/function/font_style/monospace.rb

@@ -33,6 +33,10 @@ module Plurimath
           def to_omml_without_math_tag(display_style)
             font_styles(display_style, sty: nil, scr: "monospace")
           end
+
+          def to_unicodemath
+            "ￗ#{unicodemath_parens(parameter_one)}"
+          end
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Plurimath
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
-              attributes: { mathvariant: parameter_two },
+              attributes: { mathvariant: font_family(mathml: true) },
             ),
             [first_value],
           )
@@ -33,6 +33,10 @@ module Plurimath
           parameter_one&.to_latex
         end
 
+        def to_unicodemath
+          "#{font_family(unicode: true)}#{parameter_one&.to_unicodemath}"
+        end
+
         def validate_function_formula
           true
         end
@@ -82,7 +86,7 @@ module Plurimath
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
             "#{spacing}\"#{dump_mathml(self)}\" function apply\n",
-            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+            "#{new_spacing}|_ \"#{font_family(mathml: true)}\" font family\n",
           ]
           mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr })
           new_arr
@@ -92,15 +96,28 @@ module Plurimath
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
             "#{spacing}\"#{dump_omml(self, display_style)}\" function apply\n",
-            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+            "#{new_spacing}|_ \"#{font_family(omml: true)}\" font family\n",
           ]
           omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
           new_arr
         end
 
-        def omml_and_mathml_font_family
-          fonts = Utility::FONT_STYLES.select { |_font, font_class| font_class == self.class }.keys.map(&:to_s)
-          Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts.include?(value) }
+        def font_family(unicode: false, omml: false, mathml: false)
+          fonts = font_classes
+          fonts = font_classes(parameter_to_class) if fonts.empty?
+          supported_fonts(fonts, unicode: unicode, omml: omml, mathml: mathml)
+        end
+
+        def supported_fonts(fonts_array = [], unicode: false, omml: false, mathml: false)
+          if unicode
+            font = UnicodeMath::Constants::FONTS_CLASSES.find { |value| fonts_array.include?(value) }
+            return "\\#{font}" if font
+          end
+          return Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts_array.include?(value) } if omml
+          if mathml
+            Mathml::Constants::SUPPORTED_FONT_STYLES.find { |string, object| fonts_array.include?(string.to_s) }&.first ||
+              parameter_two
+          end
         end
 
         def line_breaking(obj)
@@ -114,6 +131,14 @@ module Plurimath
             )
           )
         end
+
+        def font_classes(object = self)
+          Utility::FONT_STYLES.select { |_font, font_class| font_class == object.class }.keys.map(&:to_s)
+        end
+
+        def parameter_to_class
+          Utility::FONT_STYLES.select { |font, _font_class| font == parameter_two.to_sym }&.values&.first&.new('')
+        end
       end
     end
   end

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Frac < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "fraction",
           first_value: "numerator",
           second_value: "denominator",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options if options && !options&.empty?
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath})" if parameter_one
           second_value = "(#{parameter_two&.to_asciimath})" if parameter_two
@@ -19,12 +32,14 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          tag_name = hide_function_name ? "mfrac" : "mrow"
+          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("mfrac"), mathml_value)
+          frac_tag = ox_element(tag_name)
+          frac_tag.attributes.merge!(options) if tag_name == "mfrac" && options
+          Utility.update_nodes(frac_tag, mathml_value)
         end
 
         def to_latex
@@ -35,26 +50,35 @@ module Plurimath
 
         def to_omml_without_math_tag(display_style)
           f_element   = Utility.ox_element("f", namespace: "m")
-          fpr_element = Utility.ox_element("fPr", namespace: "m")
-          fpr_element << Utility.pr_element("ctrl", true, namespace: "m")
-          Array(
-            Utility.update_nodes(
-              f_element,
-              [
-                fpr_element,
-                omml_parameter(parameter_one, display_style, tag_name: "num"),
-                omml_parameter(parameter_two, display_style, tag_name: "den"),
-              ],
-            ),
+          Utility.update_nodes(
+            f_element,
+            [
+              fpr_element,
+              omml_parameter(parameter_one, display_style, tag_name: "num"),
+              omml_parameter(parameter_two, display_style, tag_name: "den"),
+            ],
           )
         end
 
+        def to_unicodemath
+          return unicodemath_fraction if options&.dig(:unicodemath_fraction)
+
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          second_value = unicodemath_parens(parameter_two) if parameter_two
+          return "#{first_value}/#{second_value}" unless options
+
+          return "#{first_value}¦#{second_value}" if options && options.key?(:linethickness)
+          return "#{parameter_one.to_unicodemath}⊘#{parameter_two.to_unicodemath}" if options && options.key?(:displaystyle)
+          "#{first_value}∕#{second_value}" if options && options.key?(:ldiv)
+        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))
+            frac = self.class.new(Utility.filter_values(obj.value), parameter_two)
+            frac.hide_function_name = true
+            obj.update(frac)
             self.parameter_two = nil
-            self.hide_function_name = true
             return
           end
 
@@ -65,6 +89,36 @@ module Plurimath
             obj.update(frac)
           end
         end
+
+        def choose_frac
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          second_value = unicodemath_parens(parameter_two) if parameter_two
+          "#{first_value}⒞#{second_value}"
+        end
+
+        protected
+
+        def fpr_element
+          fpr_element = Utility.ox_element("fPr", namespace: "m")
+          if options
+            attributes = { "m:val":  attr_value }
+            fpr_element << Utility.ox_element("type", namespace: "m", attributes: attributes)
+          end
+          fpr_element << Utility.pr_element("ctrl", true, namespace: "m")
+        end
+
+        def attr_value
+          if options[:linethickness] == "0"
+            "noBar"
+          else
+            options[:bevelled] == 'true' ? 'skw' : "bar"
+          end
+        end
+
+        def unicodemath_fraction
+          frac_array = [parameter_one.value.to_i, parameter_two.value.to_i]
+          UnicodeMath::Constants::UNICODE_FRACTIONS.key(frac_array)
+        end
       end
     end
   end

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

@@ -54,6 +54,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̂"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?

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

@@ -49,6 +49,36 @@ module Plurimath
             self.parameter_two = nil
           end
         end
+
+        def to_unicodemath
+          "inf#{sub_value}#{sup_value}"
+        end
+
+        protected
+
+        def sup_value
+          return unless parameter_two
+
+          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
+          return unless parameter_one
+
+          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