plurimath 0.2.0 → 0.2.2

data/lib/plurimath/asciimath/transform.rb

@@ -3,301 +3,1228 @@
 module Plurimath
   class Asciimath
     class Transform < Parslet::Transform
-      rule(expr: simple(:expr))                       { expr }
-      rule(base: simple(:base))                       { base }
-      rule(base: sequence(:base))                     { base }
-      rule(fonts: simple(:fonts))                     { fonts }
-      rule(power: simple(:power))                     { power }
-      rule(unary: simple(:unary))                     { unary }
-      rule(power: sequence(:power))                   { power }
-      rule(binary: simple(:binary))                   { binary }
-      rule(sequence: simple(:sequence))               { sequence }
-      rule(power_base: simple(:power_base))           { power_base }
-      rule(intermediate_exp: simple(:int_exp))        { int_exp }
-      rule(mod: simple(:mod), expr: simple(:expr))    { [mod, expr] }
-      rule(base: sequence(:base), expr: simple(:exp)) { base + [exp] }
+      rule(mod: simple(:mod))       { mod }
+      rule(frac: simple(:frac))     { frac }
+      rule(unary: simple(:unary))   { unary }
+      rule(table: simple(:table))   { table }
+      rule(comma: simple(:comma))   { Utility.symbol_object(comma) }
+      rule(unary: sequence(:unary)) { Utility.filter_values(unary) }
+      rule(rparen: simple(:rparen)) { Utility.symbol_object(rparen) }
+      rule(number: simple(:number)) { Math::Number.new(number) }
 
-      rule(expr: sequence(:expr)) do
-        Plurimath::Math::Formula.new(expr)
+      rule(sequence: simple(:sequence))     { sequence }
+      rule(table_row: simple(:table_row))   { table_row }
+      rule(sequence: sequence(:sequence))   { sequence }
+      rule(power_base: simple(:power_base)) { power_base }
+      rule(left_right: simple(:left_right)) { left_right }
+      rule(table_left: simple(:table_left)) { table_left }
+
+      rule(left_right: sequence(:left_right))      { left_right }
+      rule(power_base: sequence(:power_base))      { power_base }
+      rule(table_right: simple(:table_right))      { table_right }
+      rule(intermediate_exp: simple(:int_exp))     { int_exp }
+      rule(power_value: sequence(:power_value))    { power_value }
+      rule(mod: simple(:mod), expr: simple(:expr)) { [mod, expr] }
+
+      rule(bold_fonts: simple(:font)) do
+        Math::Function::FontStyle::DoubleStruck.new(
+          Utility.symbol_object(font.to_s[0]),
+          "mathbf",
+        )
       end
 
-      rule(power: sequence(:power), expr: simple(:expr)) do
-        power + [expr]
+      rule(unary_class: simple(:unary)) do
+        Utility.get_class(unary).new
       end
 
-      rule(power: sequence(:power), expr: sequence(:expr)) do
-        power + expr
+      rule(binary_class: simple(:binary)) do
+        Utility.get_class(binary).new
       end
 
-      rule(number: simple(:number)) do
-        Plurimath::Math::Number.new(number.to_s)
+      rule(comma_separated: subtree(:comma_separated)) do
+        comma_separated.flatten
       end
 
       rule(symbol: simple(:symbol)) do
-        Plurimath::Math::Symbol.new(symbol.to_s)
+        Utility.symbol_object(
+          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
+        )
+      end
+
+      rule(expr: subtree(:expr)) do
+        case expr
+        when Array
+          expr.flatten.compact
+        else
+          expr
+        end
       end
 
       rule(text: simple(:text)) do
-        text.is_a?(Slice) ? Transform.get_class("text").new(text.to_s) : text
+        text.is_a?(Slice) ? Utility.get_class("text").new(text) : text
       end
 
-      rule(base: simple(:base),
-           expr: simple(:expr)) do
-        [base, expr]
+      rule(text: sequence(:text)) do
+        Utility.get_class("text").new(text.join)
       end
 
-      rule(fonts: simple(:font_style), intermediate_exp: simple(:int_exp)) do
-        Plurimath::Math::Function::FontStyle.new(int_exp, font_style.to_s)
+      rule(power_value: simple(:power_value)) do
+        power_value
       end
 
-      rule(fonts: simple(:font_style), text: simple(:text)) do
-        parameter_one = Plurimath::Math::Function::Text.new(text.to_s)
-        Plurimath::Math::Function::FontStyle.new(parameter_one, font_style.to_s)
+      rule(base_value: simple(:base_value)) do
+        base_value
       end
 
-      rule(power_base: simple(:power_base), expr: sequence(:expr)) do
-        expr.insert(0, power_base)
+      rule(base_value: sequence(:base_value)) do
+        Utility.filter_values(base_value)
       end
 
-      rule(power_base: simple(:power_base), expr: simple(:expr)) do
-        [power_base, expr]
+      rule(numerator: simple(:numerator),
+           denominator: simple(:denominator)) do
+        new_arr = []
+        first_value = numerator.value.shift if Utility.frac_values(numerator)
+        new_arr << first_value
+        first_value = Utility.unfenced_value(numerator)
+        second_value = denominator.value.pop if Utility.frac_values(denominator)
+        new_arr << second_value
+        second_value = Utility.unfenced_value(denominator)
+        frac = Math::Function::Frac.new(
+          first_value,
+          second_value,
+        )
+        if new_arr.compact.empty?
+          frac
+        else
+          Math::Formula.new(new_arr.insert(1, frac).compact)
+        end
       end
 
-      rule(power_base: sequence(:power_base), expr: simple(:expr)) do
-        power_base + [expr]
+      rule(numerator: simple(:numerator),
+           denominator: sequence(:denominator)) do
+        new_arr = []
+        first_value = numerator.value.shift if Utility.frac_values(numerator)
+        new_arr << first_value
+        first_value = Utility.unfenced_value(numerator)
+        second_value = denominator.pop if Utility.frac_values(denominator)
+        new_arr << second_value
+        second_value = Utility.unfenced_value(denominator)
+        frac = Math::Function::Frac.new(
+          first_value,
+          second_value,
+        )
+        if new_arr.compact.empty?
+          frac
+        else
+          Math::Formula.new(new_arr.insert(1, frac).compact)
+        end
       end
 
-      rule(power_base: sequence(:power_base), expr: sequence(:expr)) do
-        power_base + expr
+      rule(sequence: simple(:sequence),
+           left_right: simple(:left_right)) do
+        new_arr = [sequence]
+        new_arr << left_right unless left_right.to_s.strip.empty?
+        new_arr
       end
 
-      rule(sequence: simple(:sequence), expr: sequence(:expr)) do
-        expr.insert(0, sequence)
+      rule(sequence: simple(:sequence),
+           left_right: sequence(:left_right)) do
+        left_right.insert(0, sequence)
+        left_right
       end
 
-      rule(dividend: simple(:dividend), mod: simple(:mod),
-           divisor: simple(:divisor)) do
-        Plurimath::Math::Function::Mod.new(dividend, divisor)
+      rule(table_row: simple(:table_row),
+           expr: simple(:expr)) do
+        new_arr = [table_row]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(table_row: simple(:table_row),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, table_row)
+      end
+
+      rule(comma: simple(:comma),
+           expr: simple(:expr)) do
+        new_arr = [Utility.symbol_object(comma)]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(comma: simple(:comma),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, Utility.symbol_object(comma))
       end
 
-      rule(unary: simple(:unary), "^": simple(:exponent),
-           number: simple(:number)) do
+      rule(rparen: simple(:rparen),
+           expr: simple(:expr)) do
         [
-          unary,
-          Plurimath::Math::Symbol.new(exponent.to_s),
-          Plurimath::Math::Number.new(number.to_s),
+          Utility.symbol_object(rparen),
+          expr,
         ]
       end
 
-      rule(unary: simple(:unary), "^": simple(:exponent),
-           intermediate_exp: simple(:intermediate_exp)) do
+      rule(rparen: simple(:rparen),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, Utility.symbol_object(rparen))
+      end
+
+      rule(rparen: simple(:rparen),
+           power: simple(:power)) do
+        Math::Function::Power.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(power),
+        )
+      end
+
+      rule(rparen: simple(:rparen),
+           power: simple(:power),
+           expr: simple(:expr)) do
+        power_object = Math::Function::Power.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(power),
+        )
+        new_arr = [power_object]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           power: simple(:power),
+           expr: sequence(:expr)) do
+        power_object = Math::Function::Power.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(power),
+        )
+        new_arr = [power_object]
+        new_arr += expr
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           base: simple(:base)) do
+        Math::Function::Base.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base),
+        )
+      end
+
+      rule(rparen: simple(:rparen),
+           base: simple(:base),
+           expr: simple(:expr)) do
+        base_object = Math::Function::Base.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base),
+        )
+        new_arr = [base_object]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           power: simple(:power),
+           comma: simple(:comma)) do
         [
-          unary,
-          Plurimath::Math::Symbol.new(exponent.to_s),
-          intermediate_exp,
+          Math::Function::Power.new(
+            Utility.symbol_object(rparen),
+            Utility.unfenced_value(power),
+          ),
+          Utility.symbol_object(comma),
         ]
       end
 
-      rule(unary: simple(:unary), "^": simple(:exponent),
-           text: simple(:text)) do
-        [
-          unary,
-          Plurimath::Math::Symbol.new(exponent.to_s),
-          text.is_a?(Slice) ? Transform.get_class("text").new(text.to_s) : text,
+      rule(rparen: simple(:rparen),
+           power: simple(:power),
+           comma: simple(:comma),
+           expr: simple(:expr)) do
+        exponent = Math::Function::Power.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(power),
+        )
+        new_arr = [
+          exponent,
+          Utility.symbol_object(comma),
         ]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
       end
 
-      rule(symbol: simple(:symbol), "^": simple(:exponent),
-           number: simple(:number)) do
-        [
-          Plurimath::Math::Symbol.new(symbol.to_s),
-          Plurimath::Math::Symbol.new(exponent.to_s),
-          Plurimath::Math::Number.new(number.to_s),
+      rule(rparen: simple(:rparen),
+           power: simple(:power),
+           comma: simple(:comma),
+           expr: sequence(:expr)) do
+        exponent = Math::Function::Power.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(power),
+        )
+        new_arr = [
+          exponent,
+          Utility.symbol_object(comma),
         ]
+        new_arr += expr
+        new_arr
       end
 
-      rule(binary: simple(:binary),
-           "^": simple(:under_score),
-           intermediate_exp: simple(:int_exp)) do
+      rule(rparen: simple(:rparen),
+           base: simple(:base),
+           comma: simple(:comma)) do
         [
-          binary,
-          Plurimath::Math::Symbol.new("^"),
-          int_exp,
+          Math::Function::Base.new(
+            Utility.symbol_object(rparen),
+            Utility.unfenced_value(base),
+          ),
+          Utility.symbol_object(comma),
         ]
       end
 
-      rule(binary: simple(:function), "^": simple(:exponent),
-           number: simple(:number)) do
+      rule(comma: simple(:comma),
+           left_right: simple(:left_right)) do
         [
-          function,
-          Plurimath::Math::Symbol.new("^"),
-          Plurimath::Math::Number.new(number.to_s),
+          Utility.symbol_object(comma),
+          left_right,
         ]
       end
 
-      Constants::UNARY_CLASSES.each do |unary_class|
-        rule(unary_class => simple(:function),
-             intermediate_exp: simple(:int_exp)) do
-          Transform.get_class(function).new(int_exp)
-        end
-
-        rule(unary_class => simple(:function),
-             _: simple(:under_score),
-             intermediate_exp: simple(:int_exp)) do
+      rule(td: simple(:td)) do
+        Math::Function::Td.new(
           [
-            Transform.get_class(function).new,
-            Plurimath::Math::Symbol.new("_"),
-            int_exp,
-          ]
+            Utility.td_value(td),
+          ],
+        )
+      end
+
+      rule(td: sequence(:td)) do
+        Utility.td_values(td, ",")
+      end
+
+      rule(open_tr: simple(:tr),
+           tds_list: simple(:tds_list)) do
+        Math::Function::Tr.new([tds_list])
+      end
+
+      rule(open_tr: simple(:tr),
+           tds_list: sequence(:tds_list)) do
+        Math::Function::Tr.new(tds_list)
+      end
+
+      rule(fonts_class: simple(:font_style),
+           fonts_value: simple(:fonts_value)) do
+        Utility::FONT_STYLES[font_style.to_sym].new(
+          Utility.unfenced_value(fonts_value),
+          font_style.to_s,
+        )
+      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
+        font_object = Utility::FONT_STYLES[font_style.to_sym].new(
+          Utility.unfenced_value(fonts_value),
+          font_style.to_s,
+        )
+        first_value = if Utility::UNARY_CLASSES.include?(function)
+                        font_object
+                      else
+                        Utility.unfenced_value(font_object)
+                      end
+        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(
+          Utility.unfenced_value(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(frac: simple(:frac),
+           expr: subtree(:expr)) do
+        case expr
+        when Array
+          expr.flatten.compact.insert(0, frac)
+        else
+          new_arr = [frac]
+          new_arr << expr unless expr.to_s.strip.empty?
+          new_arr
         end
+      end
+
+      rule(mod: simple(:mod),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, mod)
+      end
+
+      rule(frac: simple(:frac),
+           left_right: simple(:left_right)) do
+        new_arr = [frac]
+        new_arr << left_right unless left_right.to_s.strip.empty?
+        new_arr
+      end
 
-        rule(unary_class => simple(:function),
-             symbol: simple(:new_symbol)) do
-          symbol = Plurimath::Math::Symbol.new(new_symbol.to_s)
-          Transform.get_class(function).new(symbol)
+      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)
+        power_object = Math::Function::Power.new(power_base, first_value)
+        if power.empty?
+          power_object
+        else
+          [power_object] + power
         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]
+        new_arr << left_right unless left_right.to_s.strip.empty?
+        new_arr
+      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: simple(:power),
+           expr: sequence(:expr)) do
+        power_object = Math::Function::Power.new(
+          power_base,
+          Utility.unfenced_value(power),
+        )
+        Math::Formula.new(
+          expr.flatten.compact.insert(0, power_object),
+        )
+      end
+
+      rule(power_base: simple(:power_base),
+           base: simple(:base)) do
+        Math::Function::Base.new(
+          Utility.unfenced_value(power_base),
+          Utility.unfenced_value(base),
+        )
+      end
 
-        rule(unary_class => simple(:function),
-             number: simple(:new_number)) do
-          number = Plurimath::Math::Number.new(new_number.to_s)
-          Transform.get_class(function).new(number)
+      rule(power_base: simple(:power_base),
+           base: simple(:base),
+           expr: sequence(:expr)) do
+        base_object = Math::Function::Base.new(
+          Utility.unfenced_value(power_base),
+          Utility.unfenced_value(base),
+        )
+        Math::Formula.new(
+          expr.flatten.compact.insert(0, base_object),
+        )
+      end
+
+      rule(power_base: simple(:power_base),
+           base: simple(:base),
+           expr: simple(:expr)) do
+        base_object = Math::Function::Base.new(
+          Utility.unfenced_value(power_base),
+          Utility.unfenced_value(base),
+        )
+        formula_array = [base_object]
+        formula_array << expr unless expr.to_s.strip.empty?
+
+        Math::Formula.new(formula_array)
+      end
+
+      rule(power_base: simple(:power_base),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value)) do
+        Math::Function::PowerBase.new(
+          Utility.unfenced_value(power_base),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+      end
+
+      rule(power_base: simple(:power_base),
+           base_value: simple(:base_value),
+           power_value: sequence(:power_value)) do
+        first_value = power_value
+        first_value = power_value.shift if Utility.frac_values(power_value)
+        power_base_object = Math::Function::PowerBase.new(
+          Utility.unfenced_value(power_base),
+          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
+      end
 
-        rule(unary_class => simple(:function),
-             "^": simple(:base),
-             intermediate_exp: simple(:unary)) do
-          [
-            Transform.get_class(unary_class).new,
-            Plurimath::Math::Symbol.new("^"),
-            unary,
-          ]
+      rule(power_base: simple(:power_base),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value),
+           expr: sequence(:expr)) do
+        power_base_object = Math::Function::PowerBase.new(
+          Utility.unfenced_value(power_base),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        Math::Formula.new(
+          expr.flatten.compact.insert(0, power_base_object),
+        )
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value)) do
+        Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value),
+           expr: simple(:expr)) do
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        new_arr = [power_base]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: sequence(:base_value),
+           power_value: simple(:power_value),
+           expr: simple(:expr)) do
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        new_arr = [power_base]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value),
+           expr: sequence(:expr)) do
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        expr.flatten.compact.insert(0, power_base)
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: sequence(:base_value),
+           power_value: simple(:power_value),
+           expr: sequence(:expr)) do
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        expr.flatten.compact.insert(0, power_base)
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: sequence(:base_value),
+           power_value: simple(:power_value),
+           comma: simple(:comma),
+           expr: sequence(:expr)) do
+        coma = Utility.symbol_object(comma)
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        new_arr = [power_base, coma]
+        new_arr += expr.flatten.compact unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(rparen: simple(:rparen),
+           base_value: simple(:base_value),
+           power_value: simple(:power_value),
+           comma: simple(:comma),
+           expr: sequence(:expr)) do
+        coma = Utility.symbol_object(comma)
+        power_base = Math::Function::PowerBase.new(
+          Utility.symbol_object(rparen),
+          Utility.unfenced_value(base_value),
+          Utility.unfenced_value(power_value),
+        )
+        new_arr = [power_base, coma]
+        new_arr += expr.flatten.compact unless expr.to_s.strip.empty?
+        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(
+          Utility.unfenced_value(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
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(power_base: sequence(:power_base),
+           expr: sequence(:expr)) do
+        power_base + expr
+      end
+
+      rule(sequence: simple(:sequence),
+           expr: subtree(:expr)) do
+        case expr
+        when Array
+          expr.flatten.compact.insert(0, sequence)
+        else
+          new_array = [sequence]
+          new_array << expr unless expr.to_s.strip.empty?
+          new_array
         end
+      end
+
+      rule(sequence: sequence(:sequence),
+           expr: simple(:expr)) do
+        new_arr = sequence.flatten.compact
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(sequence: sequence(:sequence),
+           expr: sequence(:expr)) do
+        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(unary_class => simple(:function),
-             _: simple(:base),
-             symbol: simple(:symbol)) do
+      rule(binary_class: simple(:function),
+           base_value: simple(:base)) do
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+        )
+      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(
           [
-            Transform.get_class(unary_class).new,
-            Plurimath::Math::Symbol.new("_"),
-            Plurimath::Math::Symbol.new(symbol.to_s),
-          ]
-        end
+            Utility.symbol_object(d),
+            Utility.symbol_object(x),
+          ],
+        )
+      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(
+          Utility.unfenced_value(base),
+        )
+      end
+
+      rule(binary_class: simple(:function),
+           power: simple(:power)) do
+        Utility.get_class(function).new(
+          nil,
+          Utility.unfenced_value(power),
+        )
+      end
+
+      rule(sequence: simple(:sequence),
+           symbol: simple(:sym),
+           expr: simple(:expr)) do
+        symbol = Utility.symbol_object(
+          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
+        )
+        [sequence, symbol, expr]
+      end
+
+      rule(sequence: simple(:sequence),
+           symbol: simple(:sym),
+           expr: sequence(:expr)) do
+        symbol = Utility.symbol_object(
+          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
+        )
+        new_arr = [sequence, symbol]
+        new_arr += expr.flatten.compact unless expr.to_s.strip.empty?
+        new_arr
+      end
+
+      rule(binary_class: simple(:function),
+           base_value: simple(:base),
+           power_value: simple(:power)) do
+        Utility.get_class(function).new(
+          Utility.unfenced_value(base),
+          Utility.unfenced_value(power),
+        )
+      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)
+                        int_exp
+                      else
+                        Utility.unfenced_value(int_exp)
+                      end
+        Utility.get_class(function).new(first_value)
+      end
+
+      rule(unary_class: simple(:function),
+           symbol: simple(:symbol)) do
+        symbol_object = Utility.symbol_object(
+          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
+        )
+        Utility.get_class(function).new(symbol_object)
+      end
+
+      rule(unary_class: simple(:function),
+           number: simple(:new_number)) do
+        number = Math::Number.new(new_number)
+        Utility.get_class(function).new(number)
+      end
+
+      rule(unary_class: simple(:function),
+           unary: simple(:unary)) do
+        first_value = if Utility::UNARY_CLASSES.include?(function)
+                        unary
+                      else
+                        Utility.unfenced_value(unary)
+                      end
+        Utility.get_class(function).new(first_value)
+      end
+
+      rule(unary_class: simple(:function),
+           binary_class: simple(:binary_class)) do
+        [
+          Utility.get_class(function).new,
+          Utility.get_class(binary_class).new,
+        ]
+      end
+
+      rule(unary_class: simple(:function),
+           text: simple(:text)) do
+        Utility.get_class(function).new(
+          Math::Function::Text.new(text),
+        )
+      end
+
+      rule(number: simple(:number),
+           comma: simple(:comma)) do
+        [
+          Math::Number.new(number),
+          Utility.symbol_object(comma),
+        ]
+      end
+
+      rule(number: simple(:number),
+           power: simple(:power)) do
+        Math::Function::Power.new(
+          Math::Number.new(number),
+          Utility.unfenced_value(power),
+        )
+      end
 
-        rule(unary_class => simple(:function),
-             _: simple(:under_score),
-             base: simple(:base),
-             "^": simple(:power),
-             exponent: simple(:exponent)) do
+      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)
+      end
+
+      rule(table: simple(:table),
+           expr: simple(:expr)) do
+        formula_array = [table]
+        formula_array << expr unless expr.to_s.strip.empty?
+        Math::Formula.new(formula_array)
+      end
+
+      rule(left: simple(:left),
+           left_right_value: simple(:left_right),
+           right: simple(:right)) do
+        Math::Formula.new(
           [
-            Transform.get_class(function).new,
-            Plurimath::Math::Symbol.new("_"),
-            base,
-            Plurimath::Math::Symbol.new("^"),
-            exponent,
-          ]
-        end
+            Math::Function::Left.new(left),
+            left_right,
+            Math::Function::Right.new(right),
+          ],
+        )
       end
 
-      Constants::BINARY_CLASSES.each do |binary_class|
-        rule(binary_class => simple(:function)) do
-          Transform.get_class(function).new
-        end
+      rule(dividend: simple(:dividend),
+           mod: simple(:mod),
+           divisor: simple(:divisor)) do
+        Math::Function::Mod.new(
+          dividend,
+          divisor,
+        )
+      end
 
-        rule(binary_class => simple(:function), _: simple(:under_score),
-             base: simple(:int_exp), "^": simple(:power),
-             exponent: simple(:exponent)) do
-          Transform.get_class(function).new(int_exp, exponent)
-        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(binary_class => simple(:function), _: simple(:under_score),
-             intermediate_exp: simple(:int_exp)) do
-          Transform.get_class(function).new(int_exp, nil)
-        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(binary_class => simple(:function), "^": simple(:exponent),
-             intermediate_exp: simple(:int_exp)) do
-          Transform.get_class(function).new(nil, int_exp)
-        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(binary_class => simple(:function), _: simple(:under_score),
-             number: simple(:number)) do
-          Transform.get_class(function).new(
-            Plurimath::Math::Number.new(number.to_s), nil
-          )
-        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(binary_class => simple(:function), _: simple(:under_score),
-             symbol: simple(:symbol)) do
-          Transform.get_class(function).new(
-            Plurimath::Math::Symbol.new(symbol.to_s), nil
-          )
-        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(binary_class => simple(:function), _: simple(:under_score),
-             unary: simple(:unary)) do
-          Transform.get_class(function).new(unary, nil)
-        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(binary_class => simple(:function), "^": simple(:power),
-             number: simple(:number)) do
-          Transform.get_class(function).new(
-            nil,
-            Plurimath::Math::Number.new(number.to_s),
-          )
-        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(binary_class => simple(:function), "^": simple(:power),
-             symbol: simple(:symbol)) do
-          Transform.get_class(function).new(
-            nil,
-            Plurimath::Math::Symbol.new(symbol.to_s),
+      rule(lparen: simple(:lparen),
+           expr: simple(:expr),
+           rparen: simple(:rparen)) do
+        form_value  = if expr.is_a?(Slice)
+                        expr.to_s.empty? ? nil : [expr]
+                      else
+                        [expr]
+                      end
+        right_paren = rparen.to_s.empty? ? "" : rparen
+        if expr.is_a?(Math::Function::Text)
+          expr
+        else
+          Math::Function::Fenced.new(
+            Utility.symbol_object(lparen),
+            form_value&.flatten&.compact,
+            Utility.symbol_object(right_paren),
           )
         end
+      end
 
-        rule(binary_class => simple(:function), base: simple(:base),
-             exponent: simple(:exponent)) do
-          Transform.get_class(function).new(base, exponent)
-        end
+      rule(lparen: simple(:lparen),
+           expr: sequence(:expr),
+           rparen: simple(:rparen)) do
+        right_paren = rparen.to_s.empty? ? "" : rparen
+        Math::Function::Fenced.new(
+          Utility.symbol_object(lparen),
+          expr.flatten.compact,
+          Utility.symbol_object(right_paren),
+        )
+      end
 
-        rule(binary: simple(:function), "^": simple(:exponent),
-             text: simple(:text)) do
-          [
-            function,
-            Plurimath::Math::Symbol.new("^"),
-            text.is_a?(Slice) ? Transform.get_class("text").new(text.to_s) : text,
-          ]
-        end
+      rule(lparen: simple(:lparen),
+           text: simple(:text),
+           rparen: simple(:rparen)) do
+        Math::Function::Text.new(text)
+      end
+
+      rule(lparen: simple(:lparen),
+           rgb_color: sequence(:color),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(color)
+      end
 
-        rule(binary: simple(:function), "^": simple(:exponent),
-             unary: simple(:unary)) do
+      rule(lparen: simple(:lparen),
+           rgb_color: simple(:color),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(color)
+      end
+
+      rule(color: sequence(:color),
+           color_value: sequence(:color_value)) do
+        Utility.symbol_object(color)
+      end
+
+      rule(color: simple(:color),
+           color_value: simple(:value),
+           expr: simple(:expr)) do
+        color_object = Math::Function::Color.new(
+          color,
+          Utility.unfenced_value(value),
+        )
+        [color_object, expr]
+      end
+
+      rule(color: simple(:color),
+           color_value: simple(:value),
+           expr: sequence(:expr)) do
+        color_object = Math::Function::Color.new(
+          color,
+          Utility.unfenced_value(value),
+        )
+        expr.insert(0, color_object)
+      end
+
+      rule(color: simple(:color),
+           color_value: simple(:color_value)) do
+        first_value = if color.is_a?(Math::Function::Text)
+                        Utility.symbol_object(color.parameter_one)
+                      else
+                        color
+                      end
+        Math::Function::Color.new(
+          first_value,
+          Utility.unfenced_value(color_value),
+        )
+      end
+
+      rule(table_left: simple(:table_left),
+           table_row: simple(:table_row),
+           table_right: simple(:table_right)) do
+        Math::Function::Table.new(
           [
-            function,
-            Plurimath::Math::Symbol.new("^"),
-            unary,
-          ]
-        end
+            table_row,
+          ],
+          Utility.symbol_object(table_left).value,
+          Utility.symbol_object(table_right).value,
+        )
+      end
 
-        Constants::UNARY_CLASSES.each do |unary_class|
-          rule(binary_class => simple(:function),
-               _: simple(:base),
-               unary_class => simple(:unary)) do
-            unary_class = Transform.get_class(unary).new
-            Transform.get_class(binary_class).new(unary_class, nil)
-          end
-
-          rule(binary_class => simple(:function),
-               "^": simple(:base),
-               unary_class => simple(:unary)) do
-            unary_class = Transform.get_class(unary).new
-            Transform.get_class(binary_class).new(nil, unary_class)
-          end
-        end
+      rule(table_left: simple(:table_left),
+           table_row: simple(:table_row),
+           expr: simple(:expr),
+           table_right: simple(:table_right)) do
+        new_arr = [table_row]
+        new_arr << expr unless expr.to_s.strip.empty?
+        Math::Function::Table.new(
+          new_arr,
+          Utility.symbol_object(table_left).value,
+          Utility.symbol_object(table_right).value,
+        )
+      end
+
+      rule(norm: simple(:function),
+           table_left: simple(:table_left),
+           table_row: simple(:table_row),
+           expr: simple(:expr),
+           table_right: simple(:table_right)) do
+        table = Math::Function::Table.new(
+          [table_row, expr],
+          Utility.symbol_object(table_left).value,
+          Utility.symbol_object(table_right).value,
+        )
+        Math::Function::Norm.new(table)
       end
 
-      rule(sequence: simple(:sequence), expr: simple(:exp)) { [sequence, exp] }
+      rule(table_left: simple(:table_left),
+           table_row: simple(:table_row),
+           expr: sequence(:expr),
+           table_right: simple(:table_right)) do
+        Math::Function::Table.new(
+          expr.flatten.compact.insert(0, table_row),
+          Utility.symbol_object(table_left).value,
+          Utility.symbol_object(table_right).value,
+        )
+      end
 
-      def self.get_class(text)
-        Object.const_get("Plurimath::Math::Function::#{text.to_s.capitalize}")
+      rule(left: simple(:left),
+           table_row: simple(:table_row),
+           expr: sequence(:expr),
+           right: simple(:right)) do
+        Math::Function::Table.new(
+          expr.flatten.compact.insert(0, table_row),
+          Utility.symbol_object(left).value,
+          Utility.symbol_object(right).value,
+        )
       end
     end
   end