plurimath 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c90b0eb8f6510c5a93742653d0a9d395de3adf3b7dfa53f43d53ce4d7821a27
-  data.tar.gz: 966c4a94fc1245cec98e7290e3761be0774a71d62403e38bfa405aa1db5cd9f8
+  metadata.gz: 1b189635567597c62c87de4beda13072f0be78d12993bbf8fb88d5a62447c0d9
+  data.tar.gz: 87960dc1944b7328585f44e8d8605dd5d94d00c2e29522ceebbf6e2f09936e18
 SHA512:
-  metadata.gz: 364d72c3e42db84c13b5896ec36ea4cdb5f856ebdd970e7ff1058f3c2251cb301dd641cb51e1addcb5c890cfbd83cdebc5cf91df48e495704a8eae355b502d82
-  data.tar.gz: 607a1cf277fcbdce40ab130397985e8bf5682662adb747debb42823b257201e110d9aa4d7cb1087a191e98efeadab5976e723c2a9a6f64deb4e38bdf8fa513a1
+  metadata.gz: 4525b775b5ceb63822c1e4a0777604684b80b3c85403df64a8443d405a6e93bd3c8f354a905788558224f163caaf8a73eaca52f03f6042e409eae112f26d9805
+  data.tar.gz: b41b71415e9908bdd5bade1be722f48155473e556b050ecaebf097a21aaec1b478f63a2d72f60ead47b1a972f2c3b13623e6eb4837d426b489b39e7952bf4e0f

data/AsciiMath-Supported-Data.adoc

@@ -86,8 +86,6 @@
 * `sec`
 * `ln`
 * `ul`
-* `g`
-* `f`
 
 
 == Symbols
@@ -1588,10 +1586,10 @@
 | `Lbrack` | ⟦
 | `rBrack` | ⟧
 | `Rbrack` | ⟧
-| `langle` | ⟨
+| `langle` | 〈
 | `lAngle` | ⟪
 | `rAngle` | ⟫
-| `rangle` | ⟩
+| `rangle` | 〉
 | `lgroup` | ⟮
 | `rgroup` | ⟯
 | `Mapsto` | ⤇

data/MathML-Supported-Data.adoc

@@ -72,8 +72,6 @@
 * `sec`
 * `ln`
 * `ul`
-* `g`
-* `f`
 
 
 === Tags
@@ -214,8 +212,8 @@
 | `\⊨` | ⊨
 | `\〈` | 〈
 | `\〉` | 〉
-| `\⟨` | ⟨
-| `\⟩` | ⟩
+| `\〈` | 〈
+| `\〉` | 〉
 | `\∫` | ∫
 | `\∮` | ∮
 | `\∂` | ∂

data/lib/plurimath/asciimath/constants.rb

@@ -4,13 +4,13 @@ module Plurimath
   class Asciimath
     class Constants
       TABLE_PARENTHESIS = {
-        "(:": ":)",
+        "ᑕ": "ᑐ",
         "ℒ": "ℛ",
         "[": "]",
         "(": ")",
       }.freeze
       PARENTHESIS = {
-        "(:": ":)",
+        "ᑕ": "ᑐ",
         "ℒ": "ℛ",
         "(": ")",
         "{": "}",
@@ -286,8 +286,6 @@ module Plurimath
         vec
         ul
         ln
-        f
-        g
       ].freeze
       BINARY_CLASSES = %i[
         underset

data/lib/plurimath/asciimath/parse.rb

@@ -58,8 +58,8 @@ module Plurimath
       end
 
       rule(:quoted_text) do
-        str('"') >> match("[^\"]").repeat.as(:text) >> str('"') |
-          str('"') >> str("").as(:text)
+        (str('"') >> match("[^\"]").repeat.as(:text) >> str('"')) |
+          (str('"') >> str("").as(:text))
       end
 
       rule(:symbol_text_or_integer) do
@@ -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
 
@@ -89,16 +89,15 @@ module Plurimath
       end
 
       rule(:table) do
-        (open_table.as(:table_left) >> tr >> close_table.as(:table_right)) |
-          (open_table.as(:table_left) >> tr >> str("}").as(:table_right)) |
-          (str("norm").as(:norm) >> open_table.as(:table_left) >> tr >> close_table.as(:table_right)) |
-          (str("{").as(:table_left) >> tr >> close_table.as(:table_right)) |
-          (str("|").as(:table_left) >> tr >> str("|").as(:table_right)) |
-          (str("left") >> left_right_open_paren.as(:left) >> tr >> str("right") >> left_right_close_paren.as(:right))
+        (str("{").as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
+          (open_table.as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
+          (str("norm").as(:norm) >> open_table.as(:table_left) >> space.maybe >> tr >> space.maybe >> close_table.as(:table_right)) |
+          (str("|").as(:table_left) >> space.maybe >> tr >> space.maybe >> str("|").as(:table_right)) |
+          (str("left") >> left_right_open_paren.as(:left) >> space.maybe >> tr >> space.maybe >> str("right") >> left_right_close_paren.as(:right))
       end
 
       rule(:tr) do
-        ((left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row) >> comma >> tr.as(:expr)) |
+        ((left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row) >> comma >> space.maybe >> tr.as(:expr)) |
           (left_right_open_paren.as(:open_tr) >> td.as(:tds_list) >> left_right_close_paren).as(:table_row)
       end
 

data/lib/plurimath/asciimath/parser.rb

@@ -13,6 +13,8 @@ module Plurimath
                   &.gsub(/(\|:|:\|)/, "|")
                   &.gsub(/(\{:)/, "ℒ")
                   &.gsub(/(:\})/, "ℛ")
+                  &.gsub(/(\(:)/, "ᑕ")
+                  &.gsub(/(:\))/, "ᑐ")
       end
 
       def parse

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/html/constants.rb

@@ -34,8 +34,6 @@ module Plurimath
         det
         ln
         lg
-        g
-        f
       ].freeze
       SUB_SUP_CLASSES = {
         "∏": :prod,

data/lib/plurimath/html/transform.rb

@@ -36,6 +36,11 @@ module Plurimath
         [sequence, expr]
       end
 
+      rule(sequence: simple(:sequence),
+           parse_parenthesis: simple(:parse_paren)) do
+        [sequence, parse_paren]
+      end
+
       rule(sequence: simple(:sequence),
            expression: sequence(:expr)) do
         expr.insert(0, sequence)
@@ -72,6 +77,13 @@ module Plurimath
         )
       end
 
+      rule(unary_function: simple(:unary_function),
+           sequence: sequence(:sequence)) do
+        Math::Formula.new(
+          ([unary_function] + sequence),
+        )
+      end
+
       rule(text: simple(:text),
            expression: simple(:expr)) do
         [
@@ -250,6 +262,16 @@ module Plurimath
         end
       end
 
+      rule(sub_sup: simple(:sub_sup),
+           sup_value: sequence(:sup_value),
+           expression: simple(:expression)) do
+        power = Math::Function::Power.new(
+          sub_sup,
+          Math::Formula.new(sup_value),
+        )
+        [power, expression]
+      end
+
       rule(lparen: simple(:lparen),
            text: simple(:text),
            rparen: simple(:rparen)) do
@@ -270,6 +292,18 @@ module Plurimath
                           ])
       end
 
+      rule(lparen: simple(:lparen),
+           sequence: simple(:sequence),
+           parse_parenthesis: simple(:parse_paren),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([
+                            Math::Symbol.new(lparen),
+                            sequence,
+                            parse_paren,
+                            Math::Symbol.new(rparen),
+                          ])
+      end
+
       rule(lparen: simple(:lparen),
            sequence: sequence(:sequence),
            rparen: simple(:rparen)) do

data/lib/plurimath/latex/constants.rb

@@ -1311,8 +1311,8 @@ module Plurimath
         Lbrack: "⟦",
         rBrack: "⟧",
         Rbrack: "⟧",
-        langle: "⟨",
-        rangle: "⟩",
+        langle: "〈",
+        rangle: "〉",
         lAngle: "⟪",
         rAngle: "⟫",
         lgroup: "⟮",
@@ -3787,8 +3787,8 @@ module Plurimath
       ].freeze
       LEFT_RIGHT_PARENTHESIS = {
         "\\backslash": "\",
-        "\\langle": "⟨",
-        "\\rangle": "⟩",
+        "\\langle": "〈",
+        "\\rangle": "〉",
         "\\lfloor": "⌊",
         "\\rfloor": "⌋",
         "\\lceil": "⌈",
@@ -3828,7 +3828,7 @@ module Plurimath
         |
         }
         {
-      ]
+      ].freeze
     end
   end
 end

data/lib/plurimath/latex/parse.rb

@@ -90,7 +90,7 @@ module Plurimath
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
           match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
-          str("\\\\").as("\\\\") >> match(/\s/).repeat |
+          (str("\\\\").as("\\\\") >> match(/\s/).repeat) |
           str("\\ ").as(:space)
       end
 
@@ -140,10 +140,10 @@ module Plurimath
             (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
             expression.as(:expression).maybe
           ) >>
-         (
-           str("\\right").as(:right).maybe >> (right_parens | str(".").maybe)
-         )
-       )
+          (
+            str("\\right").as(:right).maybe >> (right_parens | str(".").maybe)
+          )
+        )
       end
 
       rule(:over_class) do
@@ -156,7 +156,7 @@ module Plurimath
 
       rule(:iteration) do
         (sequence.as(:sequence) >> iteration.as(:expression)) |
-          sequence >> expression.maybe
+          (sequence >> expression.maybe)
       end
 
       rule(:expression) do
@@ -204,7 +204,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("{") >> match("[^}]").repeat.as(:first_value) >> str("}")))
         end
       end
 

data/lib/plurimath/latex/transform.rb

@@ -310,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
@@ -319,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,
         )
@@ -554,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

@@ -6,6 +6,11 @@ module Plurimath
   module Math
     module Function
       class Fenced < TernaryFunction
+        def initialize(parameter_one = nil, parameter_two = nil, parameter_three = nil)
+          super
+          circular_parens
+        end
+
         def to_asciimath
           first_value  = parameter_one ? parameter_one.to_asciimath : "("
           third_value  = parameter_three ? parameter_three.to_asciimath : ")"
@@ -33,8 +38,8 @@ module Plurimath
           open_paren   = parameter_one ? parameter_one.value : "("
           fenced_value = parameter_two&.map(&:to_latex)&.join(" ")
           close_paren  = parameter_three ? parameter_three.value : ")"
-          first_value  = latex_paren(open_paren, false)
-          second_value = latex_paren(close_paren, true)
+          first_value  = latex_paren(open_paren)
+          second_value = latex_paren(close_paren)
           "#{first_value} #{fenced_value} #{second_value}"
         end
 
@@ -52,25 +57,6 @@ module Plurimath
 
         protected
 
-        def second_value
-          class_names = ["number", "symbol"].freeze
-          parameter_two&.map do |object|
-            e_tag = Utility.ox_element("e", namespace: "m")
-            e_tag << if class_names.include?(object.class_name)
-                       fenced_omml_value(object)
-                     else
-                       object&.to_omml_without_math_tag
-                     end
-          end
-        end
-
-        def fenced_omml_value(object)
-          r_tag = Utility.ox_element("r", namespace: "m")
-          t_tag = Utility.ox_element("t", namespace: "m")
-          t_tag << object&.value
-          r_tag << t_tag
-        end
-
         def first_value(dpr)
           first_value = parameter_one&.value
           return dpr if first_value.nil? || first_value.empty?
@@ -83,6 +69,18 @@ module Plurimath
           )
         end
 
+        def second_value
+          class_names = ["number", "symbol"].freeze
+          parameter_two&.map do |object|
+            e_tag = Utility.ox_element("e", namespace: "m")
+            e_tag << if class_names.include?(object.class_name)
+                       fenced_omml_value(object)
+                     else
+                       object&.to_omml_without_math_tag
+                     end
+          end
+        end
+
         def third_value(dpr)
           third_value = parameter_three&.value
           return dpr if third_value.nil? || third_value.empty?
@@ -95,11 +93,19 @@ module Plurimath
           )
         end
 
-        def latex_paren(paren, right)
+        def fenced_omml_value(object)
+          r_tag = Utility.ox_element("r", namespace: "m")
+          t_tag = Utility.ox_element("t", namespace: "m")
+          t_tag << object&.value
+          r_tag << t_tag
+        end
+
+        def latex_paren(paren)
           return "" if paren.nil? || paren.empty?
 
           paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
-          "#{paren}"
+          paren = "\\#{Latex::Constants::UNICODE_SYMBOLS.invert[paren]}" if paren.to_s.match?(/\&#x.{0,4};/)
+          paren.to_s
         end
 
         def mathml_paren(field)
@@ -107,6 +113,11 @@ module Plurimath
 
           field&.value
         end
+
+        def circular_parens
+          parameter_one&.value = "&#x2329;" if Utility.symbol_value(parameter_one, "ᑕ")
+          parameter_three&.value = "&#x232a;" if Utility.symbol_value(parameter_three, "ᑐ")
+        end
       end
     end
   end

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

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

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

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

data/lib/plurimath/math/symbol.rb

@@ -71,7 +71,7 @@ module Plurimath
       end
 
       def explicit_checks(unicode)
-        return true if [unicode, value].any?{|v| ["∣", "|"].include?(v) }
+        return true if [unicode, value].any? { |v| ["∣", "|"].include?(v) }
       end
 
       def specific_values

data/lib/plurimath/mathml/constants.rb

@@ -93,8 +93,8 @@ module Plurimath
         "⊨": "|==",
         "〈": "(:",
         "〉": ":)",
-        "&#x27e8;": "<<",
-        "&#x27e9;": ">>",
+        "&#x2329;": "<<",
+        "&#x232a;": ">>",
         "&#x222b;": "int",
         "&#x222e;": "oint",
         "&#x2202;": "del",
@@ -225,8 +225,6 @@ module Plurimath
         log
         ul
         ln
-        f
-        g
       ].freeze
       OPERATORS = [
         "&#x00a0;&#x00a0;&#x00a0;&#x00a0;",

data/lib/plurimath/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-11 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -101,7 +101,6 @@ files:
 - lib/plurimath/math/function/dim.rb
 - lib/plurimath/math/function/dot.rb
 - lib/plurimath/math/function/exp.rb
-- lib/plurimath/math/function/f.rb
 - lib/plurimath/math/function/fenced.rb
 - lib/plurimath/math/function/floor.rb
 - lib/plurimath/math/function/font_style.rb
@@ -114,7 +113,6 @@ files:
 - lib/plurimath/math/function/font_style/sans-serif.rb
 - lib/plurimath/math/function/font_style/script.rb
 - lib/plurimath/math/function/frac.rb
-- lib/plurimath/math/function/g.rb
 - lib/plurimath/math/function/gcd.rb
 - lib/plurimath/math/function/glb.rb
 - lib/plurimath/math/function/hat.rb

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "unary_function"
-
-module Plurimath
-  module Math
-    module Function
-      class F < UnaryFunction
-        def to_asciimath
-          "f#{parameter_one&.to_asciimath}"
-        end
-
-        def to_latex
-          first_value = latex_value if parameter_one
-          "f#{first_value}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "unary_function"
-
-module Plurimath
-  module Math
-    module Function
-      class G < UnaryFunction
-        def to_asciimath
-          "g#{parameter_one&.to_asciimath}"
-        end
-
-        def to_latex
-          "g#{parameter_one&.to_latex}"
-        end
-      end
-    end
-  end
-end