plurimath 0.8.13 → 0.8.15

data/lib/plurimath/math/formula.rb

@@ -41,14 +41,16 @@ module Plurimath
           object.left_right_wrapper == left_right_wrapper
       end
 
-      def to_asciimath
-        value.map(&:to_asciimath).join(" ")
+      def to_asciimath(formatter: nil, options: nil)
+        options ||= { formatter: formatter }
+        value.map { |val| val.to_asciimath(options: options) }.join(" ")
       rescue
         parse_error!(:asciimath)
       end
 
-      def to_mathml(display_style: displaystyle, split_on_linebreak: false, intent: false)
-        return line_breaked_mathml(display_style, intent) if split_on_linebreak
+      def to_mathml(display_style: displaystyle, split_on_linebreak: false, intent: false, formatter: nil)
+        options = { formatter: formatter }
+        return line_breaked_mathml(display_style, intent, options: options) if split_on_linebreak
 
         math_attrs = {
           xmlns: "http://www.w3.org/1998/Math/MathML",
@@ -57,7 +59,7 @@ module Plurimath
         style_attrs = { displaystyle: boolean_display_style(display_style) }
         math  = ox_element("math", attributes: math_attrs)
         style = ox_element("mstyle", attributes: style_attrs)
-        Utility.update_nodes(style, mathml_content(intent))
+        Utility.update_nodes(style, mathml_content(intent, options: options))
         Utility.update_nodes(math, [style])
         unitsml_post_processing(math.nodes, math)
         dump_nodes(math, indent: 2)
@@ -65,36 +67,38 @@ module Plurimath
         parse_error!(:mathml)
       end
 
-      def line_breaked_mathml(display_style, intent)
+      def line_breaked_mathml(display_style, intent, options:)
         new_line_support.map do |formula|
-          formula.to_mathml(display_style: display_style, intent: intent)
+          formula.to_mathml(display_style: display_style, intent: intent, formatter: options[:formatter])
         end.join
       end
 
-      def to_mathml_without_math_tag(intent)
-        return mathml_content(intent) unless left_right_wrapper
+      def to_mathml_without_math_tag(intent, options:)
+        return mathml_content(intent, options: options) unless left_right_wrapper
 
-        mathml_value = mathml_content(intent)
+        mathml_value = mathml_content(intent, options: options)
         attributes = intent_attribute(mathml_value) if intent
         mrow = ox_element("mrow", attributes: attributes)
         mrow[:unitsml] = true if unitsml
         Utility.update_nodes(mrow, mathml_value)
       end
 
-      def mathml_content(intent)
-        nodes = value.map { |val| val.to_mathml_without_math_tag(intent) }
+      def mathml_content(intent, options:)
+        nodes = value.map { |val| val.to_mathml_without_math_tag(intent, options: options) }
         intent_post_processing(nodes, intent) if intent
         nodes
       end
 
-      def to_latex
-        value&.map(&:to_latex)&.join(" ")
+      def to_latex(formatter: nil, options: nil)
+        options ||= { formatter: formatter }
+        value.map { |val| val.to_latex(options: options) }.join(" ")
       rescue
         parse_error!(:latex)
       end
 
-      def to_html
-        value&.map(&:to_html)&.join(" ")
+      def to_html(formatter: nil, options: nil)
+        options ||= { formatter: formatter }
+        value&.map { |val| val.to_html(options: options) }&.join(" ")
       rescue
         parse_error!(:html)
       end
@@ -122,14 +126,14 @@ module Plurimath
         }
       end
 
-      def to_omml(display_style: displaystyle, split_on_linebreak: false)
+      def to_omml(display_style: displaystyle, split_on_linebreak: false, formatter: nil)
         objects = split_on_linebreak ? new_line_support : [self]
-
+        options = { formatter: formatter }
         para_element = Utility.ox_element("oMathPara", attributes: omml_attrs, namespace: "m")
         objects.each.with_index(1) do |object, index|
           para_element << Utility.update_nodes(
             Utility.ox_element("oMath", namespace: "m"),
-            object.omml_content(boolean_display_style(display_style)),
+            object.omml_content(boolean_display_style(display_style), options: options),
           )
           next if objects.length == index
 
@@ -140,34 +144,40 @@ module Plurimath
         parse_error!(:omml)
       end
 
-      def omml_content(display_style)
-        value&.map { |val| val.insert_t_tag(display_style) }
+      def omml_content(display_style, options:)
+        value&.map { |val| val.insert_t_tag(display_style, options: options) }
       end
 
-      def to_omml_without_math_tag(display_style)
-        omml_content(display_style)
+      def to_omml_without_math_tag(display_style, options:)
+        omml_content(display_style, options: options)
       end
 
-      def to_unicodemath
-        Utility.html_entity_to_unicode(unicodemath_value).gsub(/\s\/\s/, "/")
+      def to_unicodemath(formatter: nil, options: nil)
+        options ||= { formatter: formatter }
+        Utility.html_entity_to_unicode(unicodemath_value(options: options)).gsub(/\s\/\s/, "/")
       rescue
         parse_error!(:unicodemath)
       end
 
-      def to_display(type = nil)
+      def to_display(type = nil, formatter: nil)
+        options = { formatter: formatter }
         return type_error! unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
 
         math_zone = case type
                     when :asciimath
-                      "  |_ \"#{to_asciimath}\"\n#{to_asciimath_math_zone("     ").join}"
+                      "  |_ \"#{to_asciimath(options: options)}\"\n#{to_asciimath_math_zone("     ", options: options).join}"
                     when :latex
-                      "  |_ \"#{to_latex}\"\n#{to_latex_math_zone("     ").join}"
+                      "  |_ \"#{to_latex(options: options)}\"\n#{to_latex_math_zone("     ", options: options).join}"
                     when :mathml
-                      "  |_ \"#{to_mathml.gsub(/\n\s*/, "")}\"\n#{to_mathml_math_zone("     ").join}"
+                      mathml = to_mathml(formatter: formatter).gsub(/\n\s*/, "")
+                      math_display = to_mathml_math_zone("     ", options: options).join
+                      "  |_ \"#{mathml}\"\n#{math_display}"
                     when :omml
-                      "  |_ \"#{to_omml.gsub(/\n\s*/, "")}\"\n#{to_omml_math_zone("     ", display_style: displaystyle).join}"
+                      omml = to_omml.gsub(/\n\s*/, "")
+                      omml_display = to_omml_math_zone("     ", display_style: displaystyle, options: options).join
+                      "  |_ \"#{omml}\"\n#{omml_display}"
                     when :unicodemath
-                      "  |_ \"#{to_unicodemath}\"\n#{to_unicodemath_math_zone("     ").join}"
+                      "  |_ \"#{to_unicodemath(options: options)}\"\n#{to_unicodemath_math_zone("     ", options: options).join}"
                     end
         <<~MATHZONE.sub(/\n$/, "")
         |_ Math zone
@@ -175,38 +185,38 @@ module Plurimath
         MATHZONE
       end
 
-      def to_asciimath_math_zone(spacing = "", last = false, indent = true)
+      def to_asciimath_math_zone(spacing = "", last = false, indent = true, options:)
         filtered_values(value, lang: :asciimath).map.with_index(1) do |object, index|
           last = index == @values.length
-          object.to_asciimath_math_zone(new_space(spacing, indent), last, indent)
+          object.to_asciimath_math_zone(new_space(spacing, indent), last, indent, options: options)
         end
       end
 
-      def to_latex_math_zone(spacing = "", last = false, indent = true)
+      def to_latex_math_zone(spacing = "", last = false, indent = true, options:)
         filtered_values(value, lang: :latex).map.with_index(1) do |object, index|
           last = index == @values.length
-          object.to_latex_math_zone(new_space(spacing, indent), last, indent)
+          object.to_latex_math_zone(new_space(spacing, indent), last, indent, options: options)
         end
       end
 
-      def to_mathml_math_zone(spacing = "", last = false, indent = true)
-        filtered_values(value, lang: :mathml).map.with_index(1) do |object, index|
+      def to_mathml_math_zone(spacing = "", last = false, indent = true, options:)
+        filtered_values(value, lang: :mathml, options: options).map.with_index(1) do |object, index|
           last = index == @values.length
-          object.to_mathml_math_zone(new_space(spacing, indent), last, indent)
+          object.to_mathml_math_zone(new_space(spacing, indent), last, indent, options: options)
         end
       end
 
-      def to_omml_math_zone(spacing = "", last = false, indent = true, display_style:)
+      def to_omml_math_zone(spacing = "", last = false, indent = true, display_style:, options:)
         filtered_values(value, lang: :omml).map.with_index(1) do |object, index|
           last = index == @values.length
-          object.to_omml_math_zone(new_space(spacing, indent), last, indent, display_style: display_style)
+          object.to_omml_math_zone(new_space(spacing, indent), last, indent, display_style: display_style, options: options)
         end
       end
 
-      def to_unicodemath_math_zone(spacing = "", last = false, indent = true)
+      def to_unicodemath_math_zone(spacing = "", last = false, indent = true, options:)
         filtered_values(value, lang: :unicodemath).map.with_index(1) do |object, index|
           last = index == @values.length
-          object.to_unicodemath_math_zone(new_space(spacing, indent), last, indent)
+          object.to_unicodemath_math_zone(new_space(spacing, indent), last, indent, options: options)
         end
       end
 
@@ -216,8 +226,8 @@ module Plurimath
         value.first.parameter_one
       end
 
-      def nary_attr_value
-        value.first.nary_attr_value
+      def nary_attr_value(options:)
+        value.first.nary_attr_value(options: Hash.new(options))
       end
 
       def validate_function_formula
@@ -338,8 +348,9 @@ module Plurimath
         value.last.is_a?(Math::Symbols::Symbol) && value.last.value == "&#x338;"
       end
 
-      def unicodemath_value
-        (negated_value? || mini_sized?) ? value&.map(&:to_unicodemath)&.join : value&.map(&:to_unicodemath)&.join(" ")
+      def unicodemath_value(options:)
+        join_str = " " if !(negated_value? || mini_sized?)
+        value&.map { |v| v.to_unicodemath(options: options) }&.join(join_str)
       end
 
       def valid_previous?(previous)
@@ -386,7 +397,7 @@ module Plurimath
         nodes.reduce do |first, second|
           if valid_partial_node(first)
             if %w[mfrac mo].include?(second.name)
-              first["intent"].gsub!("$f", "")
+              first["intent"] = first["intent"].gsub("$f", "")
             else
               second["arg"] = "f"
             end

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

@@ -8,18 +8,18 @@ module Plurimath
       class Abs < UnaryFunction
         attr_accessor :open_paren, :close_paren
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           symbol = Utility.ox_element("mo") << "|"
-          first_value = mathml_value(intent)
+          first_value = mathml_value(intent, options: options)
           first_value = first_value&.insert(0, symbol) unless open_paren
           first_value << symbol unless close_paren
           mrow = Utility.update_nodes(ox_element("mrow"), first_value)
           intentify(mrow, intent, func_name: :abs, intent_name: :"absolute-value")
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           Array(
-            md_tag << omml_parameter(parameter_one, display_style, tag_name: "e"),
+            md_tag << omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
           )
         end
 
@@ -35,8 +35,8 @@ module Plurimath
           end
         end
 
-        def to_unicodemath
-          "⒜#{unicodemath_parens(parameter_one)}"
+        def to_unicodemath(options:)
+          "⒜#{unicodemath_parens(parameter_one, options: options)}"
         end
 
         protected

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

@@ -6,14 +6,14 @@ module Plurimath
   module Math
     module Function
       class Arg < BinaryFunction
-        def to_mathml_without_math_tag(intent)
-          first_value = parameter_one.to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
+          first_value = parameter_one.to_mathml_without_math_tag(intent, options: options)
           first_value.attributes[:arg] = 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
+        def to_unicodemath(options:)
+          first_value = "(#{parameter_two&.to_unicodemath(options: options)} #{parameter_one&.to_unicodemath(options: options)})" if parameter_one || parameter_two
           "ⓐ#{first_value}"
         end
       end

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

@@ -13,17 +13,17 @@ module Plurimath
           @attributes = attributes
         end
 
-        def to_asciimath
-          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+        def to_asciimath(options:)
+          first_value = "(#{parameter_one.to_asciimath(options: options)})" if parameter_one
           "bar#{first_value}"
         end
 
-        def to_latex
-          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+        def to_latex(options:)
+          first_value = "{#{parameter_one.to_latex(options: options)}}" if parameter_one
           "\\overline#{first_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mo_tag = Utility.ox_element("mo") << "&#xaf;"
           return mo_tag unless parameter_one
 
@@ -32,16 +32,16 @@ module Plurimath
           Utility.update_nodes(
             mover_tag,
             [
-              parameter_one&.to_mathml_without_math_tag(intent),
+              parameter_one&.to_mathml_without_math_tag(intent, options: options),
               mo_tag,
             ],
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           return r_element("&#xaf;", rpr_tag: false) unless parameter_one
 
-          attributes && attributes[:accent] ? acc_tag(display_style) : bar_tag(display_style)
+          attributes && attributes[:accent] ? acc_tag(display_style, options: options) : bar_tag(display_style, options: options)
         end
 
         def swap_class
@@ -53,13 +53,13 @@ module Plurimath
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
         end
 
-        def to_unicodemath
-          "#{unicodemath_parens(parameter_one)}̅"
+        def to_unicodemath(options:)
+          "#{unicodemath_parens(parameter_one, options: options)}̅"
         end
 
         protected
 
-        def acc_tag(display_style)
+        def acc_tag(display_style, options:)
           acc = Utility.ox_element("acc", namespace: "m")
           chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "‾" } )
           acc_pr = (Utility.ox_element("accPr", namespace: "m") << chr)
@@ -67,19 +67,19 @@ module Plurimath
             acc,
             [
               acc_pr,
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
             ],
           )
           [acc]
         end
 
-        def bar_tag(display_style)
+        def bar_tag(display_style, options:)
           bar = Utility.ox_element("bar", namespace: "m")
           Utility.update_nodes(
             bar,
             [
               bar_pr,
-              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m", options: options),
             ],
           )
           [bar]

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

@@ -25,35 +25,35 @@ module Plurimath
             object.options == options
         end
 
-        def to_asciimath
-          first_value = parameter_one.to_asciimath if parameter_one
-          second_value = "_#{wrapped(parameter_two)}" if parameter_two
+        def to_asciimath(options:)
+          first_value = parameter_one.to_asciimath(options: options) if parameter_one
+          second_value = "_#{wrapped(parameter_two, options: options)}" if parameter_two
           "#{first_value}#{second_value}"
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           tag_name = Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub"
           sub_tag = Utility.ox_element("m#{tag_name}")
           mathml_value = []
-          mathml_value << validate_mathml_fields(parameter_one, intent)
-          mathml_value << validate_mathml_fields(parameter_two, intent)
+          mathml_value << validate_mathml_fields(parameter_one, intent, options: options)
+          mathml_value << validate_mathml_fields(parameter_two, intent, options: options)
           Utility.update_nodes(sub_tag, mathml_value)
         end
 
-        def to_latex
-          first_value  = parameter_one.to_latex if parameter_one
+        def to_latex(options:)
+          first_value  = parameter_one.to_latex(options: options) if parameter_one
           first_value  = "{#{first_value}}" if parameter_one.is_a?(Formula)
-          second_value = parameter_two.to_latex if parameter_two
+          second_value = parameter_two.to_latex(options: options) if parameter_two
           "#{first_value}_{#{second_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
+        def to_html(options:)
+          first_value  = "<i>#{parameter_one.to_html(options: options)}</i>" if parameter_one
+          second_value = "<sub>#{parameter_two.to_html(options: options)}</sub>" if parameter_two
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           ssub_element  = Utility.ox_element("sSub", namespace: "m")
           subpr_element = Utility.ox_element("sSubPr", namespace: "m")
           subpr_element << Utility.pr_element("ctrl", true, namespace: "m")
@@ -61,23 +61,23 @@ module Plurimath
             ssub_element,
             [
               subpr_element,
-              omml_parameter(parameter_one, display_style, tag_name: "e"),
-              omml_parameter(parameter_two, display_style, tag_name: "sub"),
+              omml_parameter(parameter_one, display_style, tag_name: "e", options: options),
+              omml_parameter(parameter_two, display_style, tag_name: "sub", options: options),
             ],
           )
           [ssub_element]
         end
 
-        def to_unicodemath
-          first_value = parameter_one.to_unicodemath if parameter_one
+        def to_unicodemath(options:)
+          first_value = parameter_one.to_unicodemath(options: options) if parameter_one
           second_value = if parameter_two.is_a?(self.class)
-            "_#{size_overrides}#{parameter_two.to_unicodemath}"
+            "_#{size_overrides}#{parameter_two.to_unicodemath(options: options)}"
           elsif parameter_two&.mini_sized?
-            parameter_two.to_unicodemath
+            parameter_two.to_unicodemath(options: options)
           elsif parameter_two.nil?
             "()"
           else
-            "_#{size_overrides}#{unicodemath_parens(parameter_two)}"
+            "_#{size_overrides}#{unicodemath_parens(parameter_two, options: options)}"
           end
           "#{first_value}#{second_value}"
         end
@@ -112,10 +112,10 @@ module Plurimath
           "Ⅎ#{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?
+        def unicodemath_parens(field, options:)
+          return "〖#{field.to_unicodemath(options: options)}〗" unless self.options.nil? || self.options&.empty?
 
-          super(field)
+          super(field, options: options)
         end
       end
     end

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

@@ -12,8 +12,8 @@ module Plurimath
           Utility.validate_left_right(variables.map { |var| get(var) })
         end
 
-        def to_asciimath
-          "#{class_name}#{wrapped(parameter_one)}#{wrapped(parameter_two)}"
+        def to_asciimath(options:)
+          "#{class_name}#{wrapped(parameter_one, options: options)}#{wrapped(parameter_two, options: options)}"
         end
 
         def ==(object)
@@ -22,11 +22,11 @@ module Plurimath
             object.parameter_two == parameter_two
         end
 
-        def to_mathml_without_math_tag(intent)
+        def to_mathml_without_math_tag(intent, options:)
           mrow_tag = Utility.ox_element("mrow")
           mo_tag = Utility.ox_element("mo") << invert_unicode_symbols.to_s
-          first_value = parameter_one&.to_mathml_without_math_tag(intent) if parameter_one
-          second_value = parameter_two&.to_mathml_without_math_tag(intent) if parameter_two
+          first_value = parameter_one&.to_mathml_without_math_tag(intent, options: options) if parameter_one
+          second_value = parameter_two&.to_mathml_without_math_tag(intent, options: options) if parameter_two
           Utility.update_nodes(
             mrow_tag,
             [
@@ -37,22 +37,22 @@ module Plurimath
           )
         end
 
-        def to_latex
-          first_value = latex_wrapped(parameter_one) if parameter_one
-          second_value = latex_wrapped(parameter_two) if parameter_two
+        def to_latex(options:)
+          first_value = latex_wrapped(parameter_one, options: options) if parameter_one
+          second_value = latex_wrapped(parameter_two, options: options) if parameter_two
           "\\#{class_name}#{first_value}#{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
+        def to_html(options:)
+          first_value = "<i>#{parameter_one.to_html(options: options)}</i>" if parameter_one
+          second_value = "<i>#{parameter_two.to_html(options: options)}</i>" if parameter_two
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(display_style, options:)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, [parameter_one.insert_t_tag(display_style)]) if parameter_one
-          Utility.update_nodes(r_tag, [parameter_two.insert_t_tag(display_style)]) if parameter_two
+          Utility.update_nodes(r_tag, [parameter_one.insert_t_tag(display_style, options: options)]) if parameter_one
+          Utility.update_nodes(r_tag, [parameter_two.insert_t_tag(display_style, options: options)]) if parameter_two
           [r_tag]
         end
 
@@ -64,81 +64,82 @@ module Plurimath
           !(parameter_one.nil? && parameter_two.nil?)
         end
 
-        def to_asciimath_math_zone(spacing, last = false, _)
+        def to_asciimath_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_asciimath}\" #{parameters[:name]}\n"]
-          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr })
-          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr })
+          new_arr = ["#{spacing}\"#{to_asciimath(options: options)}\" #{parameters[:name]}\n"]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr, options: options })
+          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr, options: options })
           new_arr
         end
 
-        def to_latex_math_zone(spacing, last = false, _)
+        def to_latex_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_latex}\" #{parameters[:name]}\n"]
-          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr })
-          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr })
+          new_arr = ["#{spacing}\"#{to_latex(options: options)}\" #{parameters[:name]}\n"]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr, options: options })
+          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr, options: options })
           new_arr
         end
 
-        def to_mathml_math_zone(spacing, last = false, _)
+        def to_mathml_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_mathml(self)}\" #{parameters[:name]}\n"]
-          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
-          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
+          new_arr = ["#{spacing}\"#{dump_mathml(self, options: options)}\" #{parameters[:name]}\n"]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, options: options })
+          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, options: options })
           new_arr
         end
 
-        def to_omml_math_zone(spacing, last = false, _, display_style:)
+        def to_omml_math_zone(spacing, last = false, _, display_style:, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{dump_omml(self, display_style)}\" #{parameters[:name]}\n"]
-          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style })
-          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style })
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style, options: options)}\" #{parameters[:name]}\n"]
+          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style, options: options })
+          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style, options: options })
           new_arr
         end
 
-        def to_unicodemath_math_zone(spacing, last = false, _)
+        def to_unicodemath_math_zone(spacing, last = false, _, options:)
           parameters = self.class::FUNCTION
           new_spacing = gsub_spacing(spacing, last)
-          new_arr = ["#{spacing}\"#{to_unicodemath}\" #{parameters[:name]}\n"]
-          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr })
-          unicodemath_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr })
+          new_arr = ["#{spacing}\"#{to_unicodemath(options: options)}\" #{parameters[:name]}\n"]
+          unicodemath_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ " , array: new_arr, options: options })
+          unicodemath_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "   |_ " , array: new_arr, options: options })
           new_arr
         end
 
         protected
 
-        def latex_wrapped(field)
+        def latex_wrapped(field, options:)
+          latex = field.to_latex(options: options)
           if field.validate_function_formula
-            "{ \\left ( #{field.to_latex} \\right ) }"
+            "{ \\left ( #{latex} \\right ) }"
           else
-            "{#{field.to_latex}}"
+            "{#{latex}}"
           end
         end
 
-        def wrapped(field)
+        def wrapped(field, options:)
           return "" unless field
 
-          "(#{field.to_asciimath})"
+          "(#{field.to_asciimath(options: options)})"
         end
 
-        def underover(display_style)
+        def underover(display_style, options:)
           return r_element(class_name, rpr_tag: false) unless all_values_exist?
 
           first_value = Symbols::Symbol.new(class_name)
           if !display_style
             power_base = PowerBase.new(first_value, parameter_one, parameter_two)
-            return power_base.to_omml_without_math_tag(display_style)
+            return power_base.to_omml_without_math_tag(display_style, options: options)
           end
 
           overset = Overset.new(first_value, parameter_two)
-          return Array(overset.to_omml_without_math_tag(display_style)) unless parameter_one
+          return Array(overset.to_omml_without_math_tag(display_style, options: options)) unless parameter_one
 
           underset = Underset.new(overset, parameter_one)
-          Array(underset.to_omml_without_math_tag(display_style))
+          Array(underset.to_omml_without_math_tag(display_style, options: options))
         end
       end
     end