plurimath 0.3.1.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70a043b8a7a5e17b083cf66545b6df58d249f1a09c3666f53090cecc14a273ae
-  data.tar.gz: e9aecbfe1aba0123fac731278428ebdb7b05197c8acbf12f9f64ab1528dea379
+  metadata.gz: dc53f153a22d8b615db765dda8d7b22c72d8cf42ee522a678649d52b3eed66b6
+  data.tar.gz: d31664e4104fe46e1361adc6b4e1a38d189590d181cf04e668c6d5d8f3a5f1d5
 SHA512:
-  metadata.gz: 07fea95bec90f3e4eb135e5fd2246b5460bf0da939111df37140f4cf64462111404558e5a67d5636b66cbf7a72f7d998107ba06273415f13b219c98cddb0df71
-  data.tar.gz: 0a116326448fb66449949741382473549ef806016e808bb9b67ddd68ff47f7a430685bf88ece03e47655199e9e23998bcae41e5e7559f8cb9c862611f899cc3e
+  metadata.gz: 6e8b0ececc1885c1751a0a9753a548f775c4cf740173c423dddbcf76dbfec8bb42db60773f744344402ea83e46e2c6bd99d43f85c54a12386383f0d83448f535
+  data.tar.gz: 4313751a9dde187e15adfbf6faa8f0c6fe015a753e286c84c2ea5cb7d5dd57c81c3e2c2e8bdaacffd1db58ff90f08fe82c5803983fe6a4027c9aade374190e8a

data/lib/plurimath/asciimath/parse.rb

@@ -70,7 +70,7 @@ module Plurimath
           quoted_text |
           (str("d").as(:d) >> str("x").as(:x)).as(:intermediate_exp) |
           match["a-zA-Z"].as(:symbol) |
-          match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?]/).as(:symbol) |
+          match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?ℒℛ]/).as(:symbol) |
           number
       end
 

data/lib/plurimath/asciimath/transform.rb

@@ -127,12 +127,6 @@ module Plurimath
         new_arr
       end
 
-      rule(sequence: simple(:sequence),
-           left_right: sequence(:left_right)) do
-        left_right.insert(0, sequence)
-        left_right
-      end
-
       rule(table_row: simple(:table_row),
            expr: simple(:expr)) do
         new_arr = [table_row]
@@ -157,6 +151,11 @@ module Plurimath
         expr.flatten.compact.insert(0, Utility.symbol_object(comma))
       end
 
+      rule(symbol: simple(:symbol),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, Utility.symbol_object(symbol))
+      end
+
       rule(rparen: simple(:rparen),
            expr: simple(:expr)) do
         [
@@ -316,19 +315,6 @@ module Plurimath
         )
       end
 
-      rule(fonts_class: simple(:font_style),
-           fonts_value: simple(:fonts_value),
-           power: simple(:power)) do
-        font_object = Utility::FONT_STYLES[font_style.to_sym].new(
-          Utility.unfenced_value(fonts_value),
-          font_style.to_s,
-        )
-        Math::Function::Power.new(
-          font_object,
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(unary_class: simple(:function),
            fonts_class: simple(:font_style),
            fonts_value: simple(:fonts_value)) do
@@ -344,24 +330,18 @@ module Plurimath
         Utility.get_class(function).new(first_value)
       end
 
-      rule(fonts_class: simple(:font_style),
-           fonts_value: simple(:fonts_value),
-           base: simple(:base)) do
-        font_object = Utility::FONT_STYLES[font_style.to_sym].new(
-          Utility.unfenced_value(fonts_value),
-          font_style.to_s,
-        )
-        Math::Function::Base.new(
-          font_object,
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(power_base: simple(:power_base),
            expr: subtree(:expr)) do
         expr.flatten.compact.insert(0, power_base)
       end
 
+      rule(power_base: simple(:power_base),
+           expr: simple(:expr)) do
+        new_arr = [power_base]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
       rule(frac: simple(:frac),
            expr: subtree(:expr)) do
         case expr
@@ -386,29 +366,6 @@ module Plurimath
         new_arr
       end
 
-      rule(sequence: simple(:sequence),
-           frac: simple(:frac)) do
-        new_arr = [sequence]
-        new_arr << frac unless frac.to_s.strip.empty?
-        new_arr
-      end
-
-      rule(sequence: simple(:sequence),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          sequence,
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(power_base: simple(:power_base),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          power_base,
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(power_base: simple(:power_base),
            power: sequence(:power)) do
         first_value = power.shift if Utility.frac_values(power)
@@ -420,16 +377,6 @@ module Plurimath
         end
       end
 
-      rule(sequence: simple(:sequence),
-           symbol: simple(:symbol)) do
-        symbol_object = Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
-        new_arr = [sequence]
-        new_arr << symbol_object unless symbol.to_s.strip.empty?
-        new_arr
-      end
-
       rule(power_base: simple(:power_base),
            left_right: simple(:left_right)) do
         new_arr = [power_base]
@@ -459,10 +406,25 @@ module Plurimath
 
       rule(power_base: simple(:power_base),
            base: simple(:base)) do
-        Math::Function::Base.new(
-          power_base,
-          Utility.unfenced_value(base),
-        )
+        if base.is_a?(Math::Formula) && base.value.any? { |value| Utility.symbol_value(value, ",") }
+          sliced = base.value.slice_before { |object| Utility.symbol_value(object, ",")  }.to_a
+          base_object = Math::Function::Base.new(
+            power_base,
+            Utility.filter_values(
+              Utility.unfenced_value(sliced.shift),
+            ),
+          )
+          [
+            base_object,
+            sliced.shift.first,
+            Utility.filter_values(sliced),
+          ].compact
+        else
+          Math::Function::Base.new(
+            power_base,
+            Utility.unfenced_value(base),
+          )
+        end
       end
 
       rule(power_base: simple(:power_base),
@@ -510,16 +472,7 @@ module Plurimath
           Utility.unfenced_value(base_value),
           Utility.filter_values(first_value),
         )
-        if power_value.empty?
-          power_base_object
-        else
-          Math::Formula.new(
-            power_value.insert(
-              0,
-              power_base_object,
-            ),
-          )
-        end
+        power_value.insert(0, power_base_object)
       end
 
       rule(power_base: simple(:power_base),
@@ -630,37 +583,6 @@ module Plurimath
         new_arr
       end
 
-      rule(intermediate_exp: simple(:int_exp),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          int_exp,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          int_exp,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          int_exp,
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(power_base: simple(:power_base),
-           expr: simple(:expr)) do
-        new_arr = [power_base]
-        new_arr << expr unless expr.to_s.strip.empty?
-        new_arr
-      end
-
       rule(power_base: sequence(:power_base),
            expr: simple(:expr)) do
         new_arr = power_base
@@ -697,22 +619,6 @@ module Plurimath
         sequence.flatten.compact + expr.flatten.compact
       end
 
-      rule(unary: simple(:unary),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          unary,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: simple(:unary),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          unary,
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(binary_class: simple(:function),
            base_value: simple(:base)) do
         Utility.get_class(function).new(
@@ -720,17 +626,6 @@ module Plurimath
         )
       end
 
-      rule(binary_class: simple(:function),
-           base_value: sequence(:base)) do
-        binary = Utility.get_class(function).new(
-          Utility.unfenced_value(base.shift),
-          Utility.unfenced_value(base.shift),
-        )
-        new_arr = [binary]
-        new_arr += base.flatten.compact unless base.empty?
-        new_arr
-      end
-
       rule(d: simple(:d),
            x: simple(:x)) do
         Math::Formula.new(
@@ -741,52 +636,6 @@ module Plurimath
         )
       end
 
-      rule(symbol: simple(:symbol),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:sym),
-           expr: sequence(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
-        expr.flatten.compact.insert(0, symbol)
-      end
-
-      rule(symbol: simple(:sym),
-           expr: simple(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
-        [symbol, expr]
-      end
-
-      rule(symbol: simple(:symbol),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(binary_class: simple(:function),
            base: simple(:base)) do
         Utility.get_class(function).new(
@@ -831,31 +680,6 @@ module Plurimath
         )
       end
 
-      rule(binary_class: simple(:function),
-           base_value: simple(:base),
-           power_value: simple(:power),
-           expr: sequence(:expr)) do
-        [
-          Utility.get_class(function).new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-        ] + expr
-      end
-
-      rule(binary_class: simple(:function),
-           base_value: simple(:base),
-           power_value: simple(:power),
-           expr: simple(:expr)) do
-        [
-          Utility.get_class(function).new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-          expr,
-        ]
-      end
-
       rule(unary_class: simple(:function),
            intermediate_exp: simple(:int_exp)) do
         first_value = if Utility::UNARY_CLASSES.include?(function)
@@ -913,54 +737,6 @@ module Plurimath
         ]
       end
 
-      rule(number: simple(:number),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(number: simple(:number),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(text: simple(:text),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(text: sequence(:text),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Math::Function::Text.new(text.join),
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(text: simple(:text),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(text: sequence(:text),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Function::Text.new(text.join),
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(table: simple(:table),
            expr: sequence(:expr)) do
         Math::Formula.new([table] + expr.flatten.compact)
@@ -994,92 +770,6 @@ module Plurimath
         )
       end
 
-      rule(text: simple(:text),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(number: simple(:number),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: simple(:unary),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          unary,
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: sequence(:unary),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        unary.first.new(
-          unary.last.new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          int_exp,
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base_value: simple(:base),
-           power_value: sequence(:power)) do
-        Math::Function::PowerBase.new(
-          int_exp,
-          Utility.unfenced_value(base),
-          Utility.filter_values(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           base_value: simple(:base),
-           power_value: sequence(:power)) do
-        symbol_object = Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
-        Math::Function::PowerBase.new(
-          symbol_object,
-          Utility.unfenced_value(base),
-          Utility.filter_values(power),
-        )
-      end
-
       rule(lparen: simple(:lparen),
            expr: simple(:expr),
            rparen: simple(:rparen)) do
@@ -1107,18 +797,6 @@ module Plurimath
         )
       end
 
-      rule(lparen: simple(:lparen),
-           text: simple(:text),
-           rparen: simple(:rparen)) do
-        Math::Function::Text.new(text)
-      end
-
-      rule(lparen: simple(:lparen),
-           text: sequence(:text),
-           rparen: simple(:rparen)) do
-        Math::Function::Text.new(text.flatten.compact.join)
-      end
-
       rule(lparen: simple(:lparen),
            rgb_color: sequence(:color),
            rparen: simple(:rparen)) do

data/lib/plurimath/latex/constants.rb

@@ -3715,6 +3715,8 @@ module Plurimath
       PARENTHESIS = {
         "[" => "]",
         "(" => ")",
+        "\\(" => "\\)",
+        "\\[" => "\\]",
         "\\{" => "\\}",
       }.freeze
       MATRICES_PARENTHESIS = {
@@ -3783,6 +3785,50 @@ module Plurimath
         bmod
         pmod
       ].freeze
+      LEFT_RIGHT_PARENTHESIS = {
+        "\\backslash": "\",
+        "\\langle": "⟨",
+        "\\rangle": "⟩",
+        "\\lfloor": "⌊",
+        "\\rfloor": "⌋",
+        "\\lceil": "⌈",
+        "\\rceil": "⌉",
+        "\\lbrace": "{",
+        "\\rbrace": "}",
+        "\\lbrack": "[",
+        "\\rbrack": "]",
+        "\\Vert": "‖",
+        "\\vert": "|",
+        "\\|": "‖",
+        "\\}": "}",
+        "\\{": "{",
+        "(": "(",
+        ")": ")",
+        "<": "<",
+        ">": ">",
+        "/": "/",
+        "|": "|",
+        "[": "[",
+        "]": "]",
+      }.freeze
+      SLASHED_SYMBOLS = %w[
+        backslash
+        langle
+        rangle
+        lfloor
+        rfloor
+        lbrace
+        rbrace
+        lbrack
+        rbrack
+        lceil
+        rceil
+        Vert
+        vert
+        |
+        }
+        {
+      ]
     end
   end
 end

data/lib/plurimath/latex/parse.rb

@@ -42,6 +42,14 @@ module Plurimath
         arr_to_expression(Constants::PARENTHESIS.values, :rparen)
       end
 
+      rule(:left_parens) do
+        arr_to_expression(Constants::LEFT_RIGHT_PARENTHESIS.keys, :left_paren)
+      end
+
+      rule(:right_parens) do
+        arr_to_expression(Constants::LEFT_RIGHT_PARENTHESIS.keys, :right_paren)
+      end
+
       rule(:environment) do
         arr_to_expression(Constants::MATRICES.keys, :environment)
       end
@@ -83,13 +91,12 @@ module Plurimath
           match["a-zA-Z"].as(:symbols) |
           match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
           str("\\\\").as("\\\\") >> match(/\s/).repeat |
-          (slash >> (lparen | rparen).as(:symbols)) |
-          lparen |
           str("\\ ").as(:space)
       end
 
       rule(:intermediate_exp) do
-        (str("{") >> expression.maybe.as(:expression) >> str("}")) |
+        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> rparen.as(:right_paren)).as(:intermediate_exp) |
+          (str("{") >> expression.maybe.as(:expression) >> str("}")) |
           symbol_text_or_integer
       end
 
@@ -123,20 +130,19 @@ module Plurimath
           (begining >> expression.as(:table_data) >> ending).as(:environment) |
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
-          (rparen >> (base >> sequence.as(:subscript)).maybe >> power >> sequence.as(:supscript)).as(:power_base) |
-          (rparen >> (power >> sequence.as(:supscript)) >> base >> sequence.as(:subscript)).as(:power_base) |
-          rparen |
           intermediate_exp
       end
 
       rule(:left_right) do
         (
-         str("\\left").as(:left) >> lparen.maybe >>
+          str("\\left").as(:left) >> (left_parens | str(".").maybe) >>
+          (
+            (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
+            expression.as(:expression).maybe
+          ) >>
          (
-           (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
-           expression.as(:expression).maybe
-         ) >>
-         str("\\right").as(:right).maybe >> (rparen | str(".").maybe)
+           str("\\right").as(:right).maybe >> (right_parens | str(".").maybe)
+         )
        )
       end
 
@@ -149,14 +155,14 @@ module Plurimath
       end
 
       rule(:iteration) do
-        (sequence.as(:sequence) >> expression.as(:expression)) |
-          sequence
+        (sequence.as(:sequence) >> iteration.as(:expression)) |
+          sequence >> expression.maybe
       end
 
       rule(:expression) do
         (iteration >> expression) |
           iteration |
-          ((iteration.as(:dividend) >> str("\\over") >> iteration.as(:divisor)) >> expression.repeat)
+          ((iteration.as(:dividend) >> str("\\over") >> iteration.as(:divisor)) >> expression.maybe)
       end
 
       root :expression
@@ -208,8 +214,9 @@ module Plurimath
 
       def unary_rules(first_value)
         (slashed_value(first_value, :unary_functions) >> dynamic_power_base) |
-          (slashed_value(first_value, :unary) >> (left_right | intermediate_exp).as(:first_value)).as(:unary_functions) |
-          (slashed_value(first_value, :unary))
+          (slashed_value(first_value, :unary) >> left_right.as(:first_value)).as(:unary_functions) |
+          (slashed_value(first_value, :unary) >> intermediate_exp.as(:first_value)).as(:unary_functions) |
+          slashed_value(first_value, :unary)
       end
 
       def dynamic_power_base

data/lib/plurimath/latex/transform.rb

@@ -24,6 +24,8 @@ module Plurimath
       rule(power_base: simple(:power_base)) { power_base }
       rule(table_data: simple(:table_data)) { table_data }
 
+      rule(intermediate_exp: simple(:int_exp)) { int_exp }
+
       rule(numeric_values: simple(:value)) do
         Math::Symbol.new(value)
       end
@@ -72,57 +74,107 @@ module Plurimath
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: sequence(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Formula.new(expr),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
+           expression: sequence(:expr),
            right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
+            Math::Formula.new(expr),
             Math::Function::Right.new,
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            expr,
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(lparen, "left"),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen)) do
-        Math::Function::Left.new(lparen)
+           left_paren: simple(:lparen)) do
+        Utility.left_right_objects(lparen, "left")
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: simple(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            expr,
+            Utility.left_right_objects(rparen, "right"),
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           expression: simple(:expr),
+           right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Math::Function::Left.new,
             expr,
-            Math::Function::Right.new(rparen),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           expression: sequence(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new,
+            Math::Formula.new(expr),
+            Math::Function::Right.new,
           ],
         )
       end
@@ -168,14 +220,14 @@ module Plurimath
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            dividend: subtree(:dividend),
            divisor: subtree(:divisor),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Function::Over.new(
               Math::Formula.new(
                 Array(dividend).flatten,
@@ -184,7 +236,7 @@ module Plurimath
                 Array(divisor).flatten,
               ),
             ),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
@@ -258,8 +310,13 @@ module Plurimath
 
       rule(unary_functions: simple(:unary),
            supscript: simple(:supscript)) do
+        unary_function = if unary.is_a?(Parslet::Slice)
+                           Utility.get_class(unary).new
+                         else
+                           unary
+                         end
         Math::Function::Power.new(
-          unary,
+          unary_function,
           supscript,
         )
       end
@@ -267,8 +324,13 @@ module Plurimath
       rule(unary_functions: simple(:unary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
+        unary_function = if unary.is_a?(Parslet::Slice)
+                           Utility.get_class(unary).new
+                         else
+                           unary
+                         end
         Math::Function::PowerBase.new(
-          unary,
+          unary_function,
           subscript,
           supscript,
         )
@@ -333,6 +395,14 @@ module Plurimath
         )
       end
 
+      rule(intermediate_exp: simple(:int_exp),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          int_exp,
+          supscript,
+        )
+      end
+
       rule(unicode_symbols: simple(:sym),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
@@ -451,6 +521,26 @@ module Plurimath
         Math::Formula.new(expr)
       end
 
+      rule(left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          [expr],
+          rparen,
+        )
+      end
+
+      rule(left_paren: simple(:lparen),
+           expression: sequence(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          expr,
+          rparen,
+        )
+      end
+
       rule(expression: sequence(:expr)) do
         Math::Formula.new(expr)
       end
@@ -474,14 +564,6 @@ module Plurimath
         )
       end
 
-      rule(rparen: simple(:rparen),
-           supscript: simple(:supscript)) do
-        Math::Function::Power.new(
-          Math::Symbol.new(rparen),
-          supscript,
-        )
-      end
-
       rule(expression: simple(:expr),
            supscript: simple(:supscript)) do
         Math::Function::Power.new(

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

@@ -6,6 +6,18 @@ module Plurimath
   module Math
     module Function
       class Dot < UnaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          dot_tag = (Utility.ox_element("mo") << ".")
+          over_tag = Utility.ox_element("mover")
+          Utility.update_nodes(
+            over_tag,
+            [
+              first_value,
+              dot_tag,
+            ],
+          )
+        end
       end
     end
   end

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

@@ -35,7 +35,7 @@ module Plurimath
           close_paren  = parameter_three ? parameter_three.value : ")"
           first_value  = latex_paren(open_paren, false)
           second_value = latex_paren(close_paren, true)
-          "#{first_value}#{fenced_value}#{second_value}"
+          "#{first_value} #{fenced_value} #{second_value}"
         end
 
         def to_omml_without_math_tag
@@ -96,11 +96,10 @@ module Plurimath
         end
 
         def latex_paren(paren, right)
-          paren_side = right ? "\\right" : "\\left"
-          return "#{paren_side} ." if paren&.include?(":")
+          return "" if paren.nil? || paren.empty?
 
           paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
-          " #{paren_side} #{paren} "
+          "#{paren}"
         end
 
         def mathml_paren(field)

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

@@ -27,8 +27,7 @@ module Plurimath
         end
 
         def to_latex
-          prefix = "\\" if parameter_one == "{"
-          "\\left #{prefix}#{parameter_one}"
+          "\\left #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || "."}"
         end
 
         protected

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

@@ -27,8 +27,7 @@ module Plurimath
         end
 
         def to_latex
-          prefix = "\\" if parameter_one == "}"
-          "\\right #{prefix}#{parameter_one}"
+          "\\right #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || "."}"
         end
 
         protected

data/lib/plurimath/utility.rb

@@ -407,6 +407,15 @@ module Plurimath
           end
         end
       end
+
+      def left_right_objects(paren, function)
+        paren = if paren.to_s.match?(/\\{|\\}/)
+                  paren.to_s.gsub(/\\/, "")
+                else
+                  Latex::Constants::LEFT_RIGHT_PARENTHESIS[paren.to_sym]
+                end
+        get_class(function).new(paren)
+      end
     end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.3.1.2"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.1.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-11 00:00:00.000000000 Z
+date: 2023-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet