plurimath 0.3.9 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d50026941bd556b94051c14a61a081ad96dbf839ed1aa324a9451382ef512e8
-  data.tar.gz: 40bf633bf5c0286daa011bf80d90baa2d522b18b9e545035d5dd6c32593792db
+  metadata.gz: 0ec251305cefca33f4a6d66180a797595d43ef370d55f7b67bdeac63b37e3111
+  data.tar.gz: 2c041edf5748e938813a20e0d397080d2f8cedcf96b19e9e39e98edae6b47ef8
 SHA512:
-  metadata.gz: 8cf6f394801e567d2a7b482a14fc4da5e3b4c19515ce549a00fc9c247ce4d26c565dc5ff72586648cd30c51c0361f40808fb1117ed408bd9c319156622b34640
-  data.tar.gz: 65d1590db64f33f620ad438ae2d328eb1fe9a6bffeee9a427dba9f782bdc9b429ed5c54e9892ade8c59894ddd57d2bcc6680a4b7cb1b9cee26c67c0cab1b05d2
+  metadata.gz: 37065161c1a09768bbec28f0d98e5438be18a5a0affa9e6024f7027ad002324c1e66e63c22f921f43fd32fa2bf1b723ace3f08b99464a8af3b7e6d265e092df6
+  data.tar.gz: 596e9cb2ce7f7d41ab8f93b4c0f330ffcdfec6adba518b49086dc4792c12f7eafed799ee087ea2ea82a3753389c179fab8883445c1b804a52fe779314941280c

data/lib/plurimath/latex/constants.rb

@@ -2853,6 +2853,7 @@ module Plurimath
         mathbfit: :fonts,
         mathfrak: :fonts,
         overline: :unary,
+        overset: :binary,
         ddagger: :symbols,
         trprime: :symbols,
         closure: :symbols,

data/lib/plurimath/latex/parse.rb

@@ -95,11 +95,18 @@ module Plurimath
       end
 
       rule(:intermediate_exp) do
-        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> rparen.as(:right_paren)).as(:intermediate_exp) |
+        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> (rparen | (str("\\") >> (match("\s") >> str(".")).maybe).as(:rparen)).maybe.as(:right_paren)).as(:intermediate_exp) |
           (str("{") >> expression.maybe.as(:expression) >> str("}")) |
           symbol_text_or_integer
       end
 
+      rule(:parsing_text_values) do
+        (str("{") >> parsing_text_values >> str("}")) >> parsing_text_values |
+          (str("{") >> parsing_text_values >> str("}")) |
+          (match("[^}]") >> parsing_text_values) |
+          match("[^}]").repeat
+      end
+
       rule(:power_base) do
         (subscript >> power >> intermediate_exp.as(:supscript)).as(:power_base) |
           (supscript >> base >> intermediate_exp.as(:subscript)).as(:power_base) |
@@ -130,7 +137,8 @@ module Plurimath
           (begining >> expression.as(:table_data) >> ending).as(:environment) |
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
-          intermediate_exp
+          intermediate_exp |
+          intermediate_exp.as(:intermediate_exp) >> rparen.as(:symbol)
       end
 
       rule(:left_right) do
@@ -204,7 +212,7 @@ module Plurimath
         when :binary
           (slashed_value(first_value, :binary) >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
         when :text
-          (slashed_value(first_value, :text) >> (str("{") >> match("[^}]").repeat.as(:first_value) >> str("}")))
+          (slashed_value(first_value, :text) >> (str("{") >> parsing_text_values.as(:first_value) >> str("}")))
         when :ternary
           (slashed_value(first_value, :ternary_functions) >> dynamic_power_base >> sequence.as(:third_value).maybe).as(:ternary_class) |
             slashed_value(first_value, :ternary)

data/lib/plurimath/latex/transform.rb

@@ -45,13 +45,9 @@ module Plurimath
       end
 
       rule(symbols: simple(:sym)) do
-        if sym.is_a?(Parslet::Slice)
-          Math::Symbol.new(
-            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
-          )
-        else
-          sym
-        end
+        Math::Symbol.new(
+          Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+        )
       end
 
       rule(lparen: simple(:lparen),
@@ -404,6 +400,16 @@ module Plurimath
         )
       end
 
+      rule(number: simple(:number),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Math::Number.new(number),
+          subscript,
+          supscript,
+        )
+      end
+
       rule(symbols: simple(:sym),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
@@ -469,6 +475,47 @@ module Plurimath
         Math::Function::Text.new(first_value)
       end
 
+      rule(text: simple(:text),
+           first_value: sequence(:first_value)) do
+        Math::Function::Text.new(first_value.join)
+      end
+
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           supscript: simple(:supscript),) do
+        Math::Function::Power.new(
+          Math::Function::Text.new(first_value),
+          supscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: sequence(:first_value),
+           supscript: simple(:supscript),) do
+        Math::Function::Power.new(
+          Math::Function::Text.new(first_value.join),
+          supscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: sequence(:first_value),
+           subscript: simple(:subscript),) do
+        Math::Function::Base.new(
+          Math::Function::Text.new(first_value.join),
+          subscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           subscript: simple(:subscript),) do
+        Math::Function::Base.new(
+          Math::Function::Text.new(first_value),
+          subscript,
+        )
+      end
+
       rule(unary: simple(:unary),
            first_value: simple(:first_value)) do
         Utility.get_class(
@@ -521,6 +568,28 @@ module Plurimath
         )
       end
 
+      rule(fonts: simple(:fonts),
+           intermediate_exp: simple(:int_exp),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        font_style = if Utility::FONT_STYLES[fonts.to_sym].nil?
+                       Math::Function::FontStyle.new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     end
+        Math::Function::PowerBase.new(
+          font_style,
+          subscript,
+          supscript,
+        )
+      end
+
       rule(root: simple(:root),
            first_value: simple(:first_value),
            second_value: simple(:second_value)) do
@@ -626,6 +695,23 @@ module Plurimath
         )
       end
 
+      rule(binary: simple(:binary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        if binary.is_a?(Parslet::Slice)
+          Utility.get_class(binary).new(
+            subscript,
+            supscript,
+          )
+        else
+          Math::Function::PowerBase.new(
+            binary,
+            subscript,
+            subscript,
+          )
+        end
+      end
+
       rule(binary: simple(:binary),
            subscript: simple(:subscript)) do
         if binary.is_a?(Parslet::Slice)

data/lib/plurimath/math/core.rb

@@ -7,8 +7,8 @@ module Plurimath
         self.class.name.split("::").last.downcase
       end
 
-      def insert_t_tag
-        Array(to_omml_without_math_tag)
+      def insert_t_tag(display_style)
+        Array(to_omml_without_math_tag(display_style))
       end
 
       def tag_name
@@ -29,13 +29,13 @@ module Plurimath
         wrapper_tag << r_tag
       end
 
-      def omml_parameter(field, tag_name: , namespace: "m")
+      def omml_parameter(field, display_style, tag_name: , namespace: "m")
         tag = Utility.ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
         Utility.update_nodes(
           tag,
-          field&.insert_t_tag,
+          field&.insert_t_tag(display_style),
         )
       end
 
@@ -52,6 +52,18 @@ module Plurimath
         r_tag << (Utility.ox_element("t", namespace: "m") << string)
         Array(r_tag)
       end
+
+      def extractable?
+        false
+      end
+
+      def extract_class_from_text
+        ""
+      end
+
+      def font_style_t_tag(display_style)
+        to_omml_without_math_tag(display_style)
+      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -8,13 +8,13 @@ module Plurimath
       def initialize(
         value = [],
         left_right_wrapper = true,
-        displaystyle: true,
+        display_style: true,
         input_string: nil
       )
         @value = value.is_a?(Array) ? value : [value]
         left_right_wrapper = false if @value.first.is_a?(Function::Left)
         @left_right_wrapper = left_right_wrapper
-        @displaystyle = displaystyle
+        @displaystyle = boolean_display_style(display_style)
       end
 
       def ==(object)
@@ -33,7 +33,7 @@ module Plurimath
           xmlns: "http://www.w3.org/1998/Math/MathML",
           display: "block",
         }
-        style_attrs = { displaystyle: display_style }
+        style_attrs = { displaystyle: boolean_display_style(display_style) }
         math  = Utility.ox_element("math", attributes: math_attrs)
         style = Utility.ox_element("mstyle", attributes: style_attrs)
         Utility.update_nodes(style, mathml_content)
@@ -91,39 +91,39 @@ module Plurimath
         }
       end
 
-      def to_omml
+      def to_omml(display_style: displaystyle)
         para_element = Utility.ox_element(
           "oMathPara",
           attributes: omml_math_attrs,
           namespace: "m",
         )
         math_element = Utility.ox_element("oMath", namespace: "m")
-        Utility.update_nodes(math_element, omml_content)
-        Utility.update_nodes(para_element, Array(math_element))
+        content = omml_content(boolean_display_style(display_style))
+        para_element << Utility.update_nodes(math_element, content)
         Ox.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
       rescue
         parse_error!(:omml)
       end
 
-      def omml_content
-        value&.map(&:insert_t_tag)
+      def omml_content(display_style)
+        value&.map { |val| val.insert_t_tag(display_style) }
       end
 
-      def to_omml_without_math_tag
-        return nary_tag if nary_tag_able?
+      def to_omml_without_math_tag(display_style)
+        return nary_tag(display_style) if nary_tag_able?(display_style)
 
-        omml_content
+        omml_content(display_style)
       end
 
-      def nary_tag
-        nary_tag = Utility.ox_element("nary", namespace: "m")
+      def nary_tag(display_style)
+        nary_element = Utility.ox_element("nary", namespace: "m")
         e_tag    = Utility.ox_element("e", namespace: "m")
-        Utility.update_nodes(e_tag, value.last.insert_t_tag)
+        Utility.update_nodes(e_tag, value.last.insert_t_tag(display_style))
         Utility.update_nodes(
-          nary_tag,
-          (value.first.omml_nary_tag << e_tag),
+          nary_element,
+          (value.first.omml_nary_tag(display_style) << e_tag),
         )
-        [nary_tag]
+        [nary_element]
       end
 
       def extract_class_from_text
@@ -136,12 +136,12 @@ module Plurimath
         value.first.nary_attr_value
       end
 
-      def nary_tag_able?
+      def nary_tag_able?(display_style)
         value.length == 2 &&
           ["underover", "powerbase"].include?(value&.first&.class_name) &&
           (
-            value&.first&.parameter_one&.to_omml_without_math_tag&.length == 1 ||
-            value&.first&.parameter_one.to_omml_without_math_tag.match?(/^&#x\w*\d*;$/)
+            value&.first&.parameter_one&.to_omml_without_math_tag(display_style)&.length == 1 ||
+            value&.first&.parameter_one.to_omml_without_math_tag(display_style).match?(/^&#x\w*\d*;$/)
           )
       end
 
@@ -151,6 +151,10 @@ module Plurimath
 
       protected
 
+      def boolean_display_style(display_style = displaystyle)
+        YAML.load(display_style.to_s)
+      end
+
       def parse_error!(type)
         Math.parse_error!(input_string, type)
       end

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

@@ -15,10 +15,10 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           md = (Utility.ox_element("d", namespace: "m") << mdpr_tag)
           me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value)
+          Utility.update_nodes(me, omml_value(display_style))
           Utility.update_nodes(md, Array(me))
           [md]
         end

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

@@ -6,38 +6,76 @@ module Plurimath
   module Math
     module Function
       class Bar < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "bar#{first_value}"
+        end
+
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\overline#{first_value}"
         end
 
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
+          mo_tag = Utility.ox_element("mo") << "&#xaf;"
+          return mo_tag unless parameter_one
+
+          mover_tag = Utility.ox_element("mover")
+          mover_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
-            Utility.ox_element("mover"),
+            mover_tag,
             [
-              first_value,
-              Utility.ox_element("mo") << "&#xaf;",
+              parameter_one&.to_mathml_without_math_tag,
+              mo_tag,
             ],
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#xaf;", rpr_tag: false) unless parameter_one
+
+          attributes && attributes[:accent] ? acc_tag(display_style) : bar_tag(display_style)
+        end
+
+        def swap_class
+          Ul.new(parameter_one, attributes)
+        end
+
+        protected
+
+        def acc_tag(display_style)
+          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)
+          Utility.update_nodes(
+            acc,
+            [
+              acc_pr,
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+            ],
+          )
+          [acc]
+        end
+
+        def bar_tag(display_style)
           bar = Utility.ox_element("bar", namespace: "m")
-          me  = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value) if parameter_one
           Utility.update_nodes(
             bar,
             [
               bar_pr,
-              me,
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
             ],
           )
           [bar]
         end
 
-        protected
-
         def bar_pr
           attrs = { "m:val": "top" }
           barpr = Utility.ox_element("barPr", namespace: "m")

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

@@ -34,7 +34,7 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           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")
@@ -42,8 +42,8 @@ module Plurimath
             ssub_element,
             [
               subpr_element,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "sub"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "sub"),
             ],
           )
           [ssub_element]

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

@@ -49,13 +49,21 @@ module Plurimath
           "#{first_value}#{second_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, [parameter_one.insert_t_tag]) if parameter_one
-          Utility.update_nodes(r_tag, [parameter_two.insert_t_tag]) if parameter_two
+          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
           [r_tag]
         end
 
+        def any_value_exist?
+          !(parameter_one.nil? || parameter_two.nil?)
+        end
+
+        def all_values_exist?
+          !(parameter_one.nil? && parameter_two.nil?)
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -82,18 +90,20 @@ module Plurimath
           wrapper_tag << r_tag
         end
 
-        def all_values_exist?
-          !(parameter_one.nil? && parameter_two.nil?)
-        end
-
-        def underover
+        def underover(display_style)
           return r_element(class_name, rpr_tag: false) unless all_values_exist?
 
           first_value = 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)
+          end
+
           overset = Overset.new(first_value, parameter_two)
-          return Array(overset.to_omml_without_math_tag) unless parameter_one
+          return Array(overset.to_omml_without_math_tag(display_style)) unless parameter_one
 
-          Array(Underset.new(overset, parameter_one)&.to_omml_without_math_tag)
+          underset = Underset.new(overset, parameter_one)
+          Array(underset.to_omml_without_math_tag(display_style))
         end
       end
     end

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

@@ -15,8 +15,8 @@ module Plurimath
           Utility.update_nodes(cancel_tag, [first_value])
         end
 
-        def to_omml_without_math_tag
-          omml_value
+        def to_omml_without_math_tag(display_style)
+          omml_value(display_style)
         end
       end
     end

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

@@ -20,11 +20,16 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
           lceil = Symbol.new("⌈")
           rceil = Symbol.new("⌉")
           fenced = Fenced.new(lceil, Array(parameter_one), rceil)
-          Array(fenced.to_omml_without_math_tag)
+          Array(fenced.to_omml_without_math_tag(display_style))
+        end
+
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          "<i>&#x2308;</i>#{first_value}<i>&#x2309;</i>"
         end
       end
     end

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

@@ -28,8 +28,8 @@ module Plurimath
           "{\\#{class_name}{#{first_value}} #{second_value}}"
         end
 
-        def to_omml_without_math_tag
-          Array(parameter_two.insert_t_tag)
+        def to_omml_without_math_tag(display_style)
+          Array(parameter_two.insert_t_tag(display_style))
         end
       end
     end

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

@@ -6,6 +6,13 @@ module Plurimath
   module Math
     module Function
       class Ddot < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           second_value = Utility.ox_element("mo") << ".."
           Utility.update_nodes(
@@ -14,18 +21,16 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
-          acc_tag    = Utility.ox_element("acc", namespace: "m")
-          acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
-          acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": ".." }))
-          Utility.update_nodes(
-            acc_tag,
-            [
-              acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
-            ],
-          )
-          [acc_tag]
+        def to_omml_without_math_tag(display_style)
+          return r_element("..", rpr_tag: false) unless parameter_one
+
+          symbol = Symbol.new("..")
+          Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+        end
+
+        def to_html
+          first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          "#{first_value}<i>..</i>"
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("deg"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("deg", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("det"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("det", rpr_tag: false), omml_value(display_style)]
         end
       end
     end

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

@@ -10,8 +10,8 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          [r_element("dim"), omml_value]
+        def to_omml_without_math_tag(display_style)
+          [r_element("dim", rpr_tag: false), omml_value(display_style)]
         end
       end
     end