plurimath 0.2.0 → 0.2.2

data/lib/plurimath/latex/transform.rb

@@ -3,176 +3,537 @@
 module Plurimath
   class Latex
     class Transform < Parslet::Transform
-      rule(base: simple(:base))      { base }
-      rule(text: simple(:text))      { Math::Function::Text.new(text.to_s) }
-      rule(number: simple(:num))     { Math::Number.new(num.to_s) }
-      rule(power: simple(:power))    { power }
-      rule(symbols: simple(:sym))    { Math::Symbol.new(sym.to_s) }
-      rule(operant: simple(:oper))   { Math::Symbol.new(oper.to_s) }
-      rule(ending: simple(:ending))  { nil }
-      rule(limits: simple(:limits))  { limits }
+      rule(base: simple(:base))       { base }
+      rule(over: simple(:over))       { over }
+      rule(number: simple(:num))      { Math::Number.new(num) }
+      rule(power: simple(:power))     { power }
+      rule(unary: simple(:unary))     { Utility.get_class(unary).new }
+      rule(space: simple(:space))     { Math::Function::Text.new(" ") }
+      rule(operant: simple(:oper))    { Math::Symbol.new(oper) }
+      rule(symbol: simple(:symbol))   { Math::Symbol.new(symbol) }
+      rule(lparen: simple(:lparen))   { Math::Symbol.new(lparen) }
+      rule(rparen: simple(:rparen))   { Math::Symbol.new(rparen) }
+      rule(limits: simple(:limits))   { limits }
+      rule("\\\\" => simple(:slash))  { Math::Symbol.new(slash) }
+      rule(expression: simple(:expr)) { expr }
+      rule(environment: simple(:env)) { env }
+
+      rule(unary_functions: simple(:unary)) { unary }
+      rule(left_right: simple(:left_right)) { left_right }
+      rule(under_over: simple(:under_over)) { under_over }
+      rule(power_base: simple(:power_base)) { power_base }
+      rule(table_data: simple(:table_data)) { table_data }
+
+      rule(numeric_values: simple(:value)) do
+        Math::Symbol.new(value)
+      end
+
+      rule(text: simple(:text)) do
+        Math::Function::Text.new(text)
+      end
+
+      rule(unicode_symbols: simple(:unicode)) do
+        Math::Unicode.new(unicode)
+      end
+
       rule(binary: simple(:binary)) do
-        binary.is_a?(Slice) ? Transform.get_class(binary == "over" ? "overset" : binary).new : binary
+        binary.is_a?(Parslet::Slice) ? Utility.get_class(binary).new : binary
       end
-      rule("\\\\" => simple(:slash)) { Math::Symbol.new(slash.to_s) }
 
-      rule(unary_functions: simple(:unary))    { unary }
-      rule(under_over: simple(:under_over))    { under_over }
-      rule(power_base: simple(:power_base))    { power_base }
-      rule(table_data: simple(:table_data))    { table_data }
-      rule(environment: simple(:environment))  { environment }
-      rule(intermediate_exp: simple(:int_exp)) { int_exp }
-      rule(lparen: simple(:lparen), rparen: simple(:rparen)) { nil }
+      rule(symbols: simple(:sym)) do
+        if sym.is_a?(Parslet::Slice)
+          Math::Symbol.new(
+            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+          )
+        else
+          sym
+        end
+      end
 
-      rule(left_right: simple(:left_right)) do
-        Math::Function::Left.new(left_right)
+      rule(lparen: simple(:lparen),
+           rparen: simple(:rparen)) do
+        []
       end
 
-      rule(fonts: simple(:fonts), intermediate_exp: simple(:int_exp)) do
-        Math::Function::FontStyle.new(int_exp, fonts.to_s)
+      rule(left_right: simple(:left_right),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          left_right,
+          subscript,
+        )
       end
 
-      rule(number: simple(:number), subscript: simple(:subscript)) do
-        number_object = Math::Number.new(number.to_s)
-        Math::Function::Base.new(number_object, subscript)
+      rule(left_right: simple(:left_right),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          left_right,
+          supscript,
+        )
       end
 
-      rule(symbols: simple(:symbol), subscript: simple(:subscript)) do
-        symbol_object = Math::Symbol.new(symbol.to_s)
-        Math::Function::Base.new(symbol_object, subscript)
+      rule(left: simple(:left),
+           lparen: simple(:lparen),
+           expression: sequence(:expr),
+           right: simple(:right),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            Math::Formula.new(expr),
+            Math::Function::Right.new(rparen),
+          ],
+        )
       end
 
-      rule(text: simple(:text), subscript: simple(:subscript)) do
-        text_object = Math::Function::Text.new(text.to_s)
-        Math::Function::Base.new(text_object, subscript)
+      rule(left: simple(:left),
+           lparen: simple(:lparen),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            Math::Function::Right.new,
+          ],
+        )
       end
 
-      rule(text: simple(:text), supscript: simple(:supscript)) do
-        text_object = Math::Function::Text.new(text.to_s)
-        Math::Function::Power.new(text_object, supscript)
+      rule(left: simple(:left),
+           lparen: simple(:lparen),
+           right: simple(:right),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            Math::Function::Right.new(rparen),
+          ],
+        )
       end
 
-      rule(unary: simple(:unary), first_value: simple(:first_value)) do
-        class_name = unary == "overline" ? "bar" : unary
-        Transform.get_class(class_name).new(first_value)
+      rule(left: simple(:left),
+           lparen: simple(:lparen)) do
+        Math::Function::Left.new(lparen)
       end
 
-      rule(sqrt: simple(:sqrt), intermediate_exp: simple(:int_exp)) do
-        Math::Function::Sqrt.new(int_exp)
+      rule(left: simple(:left),
+           lparen: simple(:lparen),
+           expression: simple(:expr),
+           right: simple(:right),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            expr,
+            Math::Function::Right.new(rparen),
+          ],
+        )
       end
 
-      rule(root: simple(:root),
-           first_value: simple(:first_value),
-           second_value: simple(:second_value)) do
-        Math::Function::Root.new(first_value, second_value)
+      rule(power: simple(:power),
+           number: simple(:number)) do
+        Math::Function::Power.new(
+          power,
+          Math::Number.new(number),
+        )
       end
 
-      rule(sequence: simple(:sequence), expression: simple(:expr)) do
-        [sequence, expr]
+      rule(power: simple(:power),
+           expression: simple(:expr)) do
+        Math::Function::Power.new(
+          power,
+          expr,
+        )
       end
 
-      rule(sequence: simple(:sequence), expression: sequence(:expr)) do
-        [sequence] + expr
+      rule(base: simple(:base),
+           expression: simple(:expr)) do
+        Math::Function::Base.new(
+          base,
+          expr,
+        )
       end
 
-      rule(unary_functions: simple(:unary),
-           base: simple(:base),
-           power: simple(:power)) do
-        Plurimath::Math::Function::Limits.new(
-          Transform.get_class(unary).new,
+      rule(base: simple(:base),
+           expression: sequence(:expr)) do
+        Math::Function::Base.new(
           base,
+          Utility.filter_values(expr),
+        )
+      end
+
+      rule(power: simple(:power),
+           expression: sequence(:expr)) do
+        Math::Function::Power.new(
           power,
+          Utility.filter_values(expr),
         )
       end
 
-      rule(lparen: simple(:lparen),
-           text: simple(:text),
+      rule(left: simple(:left),
+           lparen: simple(:lparen),
+           dividend: subtree(:dividend),
+           divisor: subtree(:divisor),
+           right: simple(:right),
            rparen: simple(:rparen)) do
-        Math::Function::Text.new(text.to_s)
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            Math::Function::Over.new(
+              Math::Formula.new(
+                Array(dividend).flatten,
+              ),
+              Math::Formula.new(
+                Array(divisor).flatten,
+              ),
+            ),
+            Math::Function::Right.new(rparen),
+          ],
+        )
       end
 
-      rule(lparen: simple(:lparen),
-           symbols: simple(:symbol),
-           rparen: simple(:rparen)) do
-        Math::Symbol.new(symbol.to_s)
+      rule(dividend: subtree(:dividend),
+           divisor: subtree(:divisor)) do
+        Math::Function::Over.new(
+          Math::Formula.new(
+            Array(dividend).flatten,
+          ),
+          Math::Formula.new(
+            Array(divisor).flatten,
+          ),
+        )
       end
 
-      rule(substack: simple(:substack),
-           lparen: simple(:lparen),
-           substack_value: sequence(:value),
-           rparen: simple(:rparen)) do
-        first_value = []
-        until value.nil?
-          if value.first.is_a?(Plurimath::Math::Symbol) &&
-             value.first.value == "\\\\"
-            value.delete_at(0)
-            break;
-          else
-            first_value << value.delete_at(0)
-          end
-        end
-        Transform.get_class(substack).new(
-          Math::Formula.new(first_value),
-          Math::Formula.new(value)
+      rule(over: simple(:over),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          over,
+          subscript,
         )
       end
 
-      rule(lparen: simple(:lparen),
-           sequence: simple(:sequence),
-           expression: sequence(:expr),
-           rparen: simple(:rparen)) do
-        Math::Formula.new([sequence] + expr)
+      rule(over: simple(:over),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          over,
+          supscript,
+        )
       end
 
-      rule(lparen: simple(:lparen),
-           sequence: simple(:sequence),
-           expression: simple(:expr),
-           rparen: simple(:rparen)) do
-        Math::Formula.new([sequence, expr])
+      rule(operant: simple(:operant),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Symbol.new(operant),
+          subscript,
+        )
       end
 
-      rule(lparen: simple(:lparen),
-           expression: simple(:expr),
-           rparen: simple(:rparen)) do
-        if expr.is_a?(Slice) && Constants::ENVIRONMENTS.key?(expr.to_s)
-          open_paren = Constants::ENVIRONMENTS[expr.to_s]
-          close_paren = if Constants::PARENTHESIS[open_paren]
-                          Constants::PARENTHESIS[open_paren]
-                        elsif open_paren == "|"
-                          "|"
-                        end
-          Math::Function::Table.new(
-            nil,
-            open_paren,
-            close_paren,
+      rule(sequence: simple(:sequence),
+           expression: simple(:expr)) do
+        [sequence, expr].compact
+      end
+
+      rule(sequence: simple(:sequence),
+           expression: sequence(:expr)) do
+        [sequence] + expr
+      end
+
+      rule(unary_functions: simple(:unary),
+           subscript: simple(:subscript)) do
+        unary_function = if unary.is_a?(Parslet::Slice)
+                           Utility.get_class(unary).new
+                         else
+                           unary
+                         end
+        Math::Function::Base.new(
+          unary_function,
+          subscript,
+        )
+      end
+
+      rule(binary_functions: simple(:binary),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          binary,
+          supscript,
+        )
+      end
+
+      rule(unary_functions: simple(:unary),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          unary,
+          supscript,
+        )
+      end
+
+      rule(unary_functions: simple(:unary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          unary,
+          subscript,
+          supscript,
+        )
+      end
+
+      rule(fonts: simple(:fonts),
+           intermediate_exp: simple(:int_exp)) do
+        if Utility::FONT_STYLES[fonts.to_sym]
+          Utility::FONT_STYLES[fonts.to_sym].new(
+            int_exp,
+            fonts.to_s,
           )
         else
-          expr
+          Math::Function::FontStyle.new(
+            int_exp,
+            fonts.to_s,
+          )
         end
       end
 
+      rule(number: simple(:number),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Number.new(number),
+          subscript,
+        )
+      end
+
+      rule(number: simple(:number),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Number.new(number),
+          supscript,
+        )
+      end
+
+      rule(symbols: simple(:sym),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Symbol.new(
+            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+          ),
+          subscript,
+        )
+      end
+
+      rule(numeric_values: simple(:value),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Symbol.new(value),
+          subscript,
+        )
+      end
+
+      rule(symbols: simple(:sym),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Symbol.new(
+            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+          ),
+          supscript,
+        )
+      end
+
+      rule(unicode_symbols: simple(:sym),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Unicode.new(sym),
+          subscript,
+        )
+      end
+
+      rule(unicode_symbols: simple(:sym),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Unicode.new(sym),
+          supscript,
+        )
+      end
+
+      rule(numeric_values: simple(:value),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Symbol.new(value),
+          supscript,
+        )
+      end
+
+      rule(unary: simple(:unary),
+           first_value: simple(:first_value)) do
+        Utility.get_class(
+          unary == "overline" ? "bar" : unary,
+        ).new(first_value)
+      end
+
+      rule(sqrt: simple(:sqrt),
+           intermediate_exp: simple(:int_exp)) do
+        Math::Function::Sqrt.new(int_exp)
+      end
+
+      rule(fonts: simple(:fonts),
+           intermediate_exp: simple(:int_exp),
+           supscript: simple(:supscript)) do
+        font_style = if Utility::FONT_STYLES[fonts.to_sym].nil?
+                       Math::Function::FontStyle.new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     end
+        Math::Function::Power.new(
+          font_style,
+          supscript,
+        )
+      end
+
+      rule(fonts: simple(:fonts),
+           intermediate_exp: simple(:int_exp),
+           subscript: simple(:subscript)) do
+        font_style = if Utility::FONT_STYLES[fonts.to_sym].nil?
+                       Math::Function::FontStyle.new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts.to_s,
+                       )
+                     end
+        Math::Function::Base.new(
+          font_style,
+          subscript,
+        )
+      end
+
+      rule(root: simple(:root),
+           first_value: simple(:first_value),
+           second_value: simple(:second_value)) do
+        second = second_value.nil? ? Math::Formula.new : second_value
+        Math::Function::Root.new(
+          first_value,
+          second,
+        )
+      end
+
+      rule(root: simple(:root),
+           first_value: sequence(:first_value),
+           second_value: simple(:second_value)) do
+        first = Utility.filter_values(first_value)
+        first = first.nil? ? Math::Formula.new : first
+        Math::Function::Root.new(
+          first,
+          second_value,
+        )
+      end
+
+      rule(first_value: simple(:first_value),
+           base: simple(:base),
+           power: simple(:power)) do
+        Math::Function::Limits.new(
+          first_value,
+          base,
+          power,
+        )
+      end
+
       rule(lparen: simple(:lparen),
            expression: sequence(:expr),
            rparen: simple(:rparen)) do
         Math::Formula.new(expr)
       end
 
+      rule(expression: sequence(:expr)) do
+        Math::Formula.new(expr)
+      end
+
+      rule(rule: simple(:rule),
+           first_value: simple(:first_value),
+           second_value: simple(:second_value),
+           third_value: simple(:third_value)) do
+        Math::Function::Rule.new(
+          first_value,
+          second_value,
+          third_value,
+        )
+      end
+
+      rule(expression: simple(:expression),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          expression,
+          subscript,
+        )
+      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(
+          expr,
+          supscript,
+        )
+      end
+
+      rule(expression: sequence(:expr),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Utility.filter_values(expr),
+          supscript,
+        )
+      end
+
       rule(binary: simple(:binary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
-        Transform.get_class(binary).new(subscript, supscript)
+        Utility.get_class(binary).new(
+          subscript,
+          supscript,
+        )
       end
 
       rule(binary: simple(:binary),
            subscript: simple(:subscript)) do
-        Transform.get_class(binary).new(subscript)
+        if binary.is_a?(Parslet::Slice)
+          Utility.get_class(binary).new(subscript)
+        else
+          Math::Function::Base.new(
+            binary,
+            subscript,
+          )
+        end
       end
 
-      rule(text: simple(:text),
+      rule(symbols: simple(:sym),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
-        text_object = Math::Function::Text.new(text.to_s)
-        Math::Function::PowerBase.new(text_object, subscript, supscript)
+        Math::Function::PowerBase.new(
+          Math::Symbol.new(
+            Constants::UNICODE_SYMBOLS[sym.to_sym] || sym,
+          ),
+          subscript,
+          supscript,
+        )
+      end
+
+      rule(unicode_symbols: simple(:sym),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Math::Unicode.new(sym),
+          subscript,
+          supscript,
+        )
       end
 
       rule(binary: simple(:binary),
@@ -180,118 +541,172 @@ module Plurimath
            second_value: simple(:second_value)) do
         if binary == "binom"
           Math::Function::Table.new(
-            [Math::Function::Tr.new([first_value]),
-             Math::Function::Tr.new([second_value])],
+            [
+              Math::Function::Tr.new(
+                Utility.table_td(first_value),
+              ),
+              Math::Function::Tr.new(
+                Utility.table_td(second_value),
+              ),
+            ],
             "(",
             ")",
           )
         else
-          binary_class = if ["pmod", "bmod"].include?(binary)
-                           "mod"
-                         elsif binary == "over"
-                           "frac"
-                         else
-                           binary
-                         end
-          Transform.get_class(binary_class).new(first_value, second_value)
+          Utility.get_class(
+            binary.to_s.include?("mod") ? "mod" : binary,
+          ).new(
+            first_value,
+            second_value,
+          )
         end
       end
 
-      rule(begining: simple(:begining),
+      rule(underover: simple(:function),
+           first_value: simple(:first),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Utility.get_class(function).new(first),
+          subscript,
+          supscript,
+        )
+      end
+
+      rule(environment: simple(:environment),
            table_data: sequence(:table_data),
            ending: simple(:ending)) do
-        begining.parameter_one = Transform.organize_table(table_data)
-        begining
+        open_paren = Constants::MATRICES[environment.to_sym]
+        Utility.get_table_class(environment).new(
+          Utility.organize_table(table_data),
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          {},
+        )
       end
 
-      rule(lparen: simple(:lparen),
-           environment: simple(:env),
-           rparen: simple(:rparen)) do
-        env
+      rule(environment: simple(:environment),
+           args: simple(:args),
+           table_data: simple(:table_data),
+           ending: simple(:ending)) do
+        third_value = args ? [args] : []
+        open_paren = Constants::MATRICES[environment.to_sym]
+        table = Utility.organize_table(
+          [table_data],
+          column_align: third_value,
+        )
+        Utility.get_table_class(environment).new(
+          table,
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          Utility.table_options(table),
+        )
       end
 
-      rule(begining: simple(:begining),
-           args: simple(:args),
+      rule(environment: simple(:environment),
            table_data: simple(:table_data),
            ending: simple(:ending)) do
-        table_value = Transform.organize_table([table_data])
-        begining.parameter_one = table_value
-        begining.parameter_three = [args]
-        begining
+        open_paren = Constants::MATRICES[environment.to_sym]
+        Utility.get_table_class(environment).new(
+          Utility.organize_table([table_data]),
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+        )
       end
 
-      rule(begining: simple(:begining),
+      rule(environment: simple(:environment),
            args: sequence(:args),
            table_data: sequence(:table_data),
            ending: simple(:ending)) do
-        table_value = Transform.organize_table(table_data)
-        begining.parameter_one = table_value
-        begining.parameter_three = args
-        begining
+        open_paren = Constants::MATRICES[environment.to_sym]
+        table = Utility.organize_table(table_data, column_align: args)
+        Utility.get_table_class(environment).new(
+          table,
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          Utility.table_options(table),
+        )
       end
 
-      rule(begining: simple(:begining),
+      rule(environment: simple(:environment),
            args: simple(:args),
            table_data: sequence(:table_data),
            ending: simple(:ending)) do
-        table_value = Transform.organize_table(table_data)
-        begining.parameter_one = table_value
-        begining.parameter_three = [args]
-        begining
+        third_value = args ? [args] : []
+        open_paren = Constants::MATRICES[environment.to_sym]
+        table = Utility.organize_table(table_data, column_align: third_value)
+        Utility.get_table_class(environment).new(
+          table,
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          Utility.table_options(table),
+        )
+      end
+
+      rule(environment: simple(:environment),
+           asterisk: simple(:asterisk),
+           options: simple(:options),
+           table_data: sequence(:table_data),
+           ending: simple(:ending)) do
+        third_value = options ? [options] : []
+        open_paren = Constants::MATRICES[environment.to_sym]
+        table = Utility.organize_table(
+          table_data,
+          column_align: third_value,
+          options: true,
+        )
+        Utility.get_table_class(environment).new(
+          table,
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          { asterisk: true },
+        )
+      end
+
+      rule(environment: simple(:environment),
+           asterisk: simple(:asterisk),
+           table_data: sequence(:table_data),
+           ending: simple(:ending)) do
+        open_paren = Constants::MATRICES[environment.to_sym]
+        Utility.get_table_class(environment).new(
+          Utility.organize_table(table_data),
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          { asterisk: true },
+        )
       end
 
       rule(environment: simple(:env),
-           lparen: simple(:lparen),
-           expression: sequence(:expr),
-           rparen: simple(:rparen)) do
-        table_value = Transform.organize_table(expr)
-        left_paren = Constants::ENVIRONMENTS[env.to_s]
-        Math::Function::Table.new(
-          table_value,
-          left_paren,
-          Constants::PARENTHESIS[left_paren],
+           expression: simple(:expr)) do
+        open_paren = Constants::MATRICES[env.to_sym]
+        Utility.get_table_class(env).new(
+          Utility.organize_table(expr.nil? ? [] : [expr]),
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          {},
         )
       end
 
-      rule(lparen: simple(:lparen),
-           expression: sequence(:expr),
-           rparen: simple(:rparen),
-           supscript: simple(:supscript)) do
-        formula = Math::Formula.new(expr)
-        Math::Function::Power.new(formula, supscript)
+      rule(environment: simple(:env),
+           expression: sequence(:expr)) do
+        open_paren = Constants::MATRICES[env.to_sym]
+        Utility.get_table_class(env).new(
+          Utility.organize_table(expr.compact),
+          open_paren,
+          Constants::MATRICES_PARENTHESIS[open_paren&.to_sym]&.to_s,
+          {},
+        )
       end
 
-      rule(lparen: simple(:lparen),
-           expression: simple(:expr),
-           rparen: simple(:rparen),
-           subscript: simple(:subscript)) do
-        formula = Math::Formula.new(expr)
-        Math::Function::Base.new(formula, subscript)
-      end
-
-      class << self
-        def organize_table(array, table = [], table_data = [], table_row = [])
-          array.each do |data|
-            if data.is_a?(Math::Symbol) && data.value == "&"
-              table_row << Math::Function::Td.new(table_data)
-              table_data = []
-            elsif data.is_a?(Math::Symbol) && data.value == "\\\\"
-              table_row << Math::Function::Td.new(table_data)
-              table << Math::Function::Tr.new(table_row.flatten)
-              table_row  = []
-              table_data = []
-            else
-              table_data << data
-            end
-          end
-          table_row << Math::Function::Td.new(table_data) if table_data
-          table << Math::Function::Tr.new(table_row) unless table_row.empty?
-          table
-        end
+      rule(substack: simple(:substack),
+           expression: sequence(:value)) do
+        tds = Utility.td_values(value, "\\\\")
 
-        def get_class(text)
-          Object.const_get("Plurimath::Math::Function::#{text.to_s.capitalize}")
-        end
+        substack_values = tds.map { |td| Math::Function::Tr.new([td]) }
+        Math::Function::Substack.new(
+          substack_values.shift,
+          substack_values.shift,
+        )
       end
     end
   end