plurimath 0.2.0 → 0.2.1

data/lib/plurimath/latex/transform.rb

@@ -3,176 +3,372 @@
 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(operant: simple(:oper))  { Math::Symbol.new(oper) }
+      rule("\\\\": simple(:slash))  { Math::Symbol.new(slash) }
+      rule(limits: simple(:limits)) { limits }
+
+      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(environment: simple(:environment)) { environment }
+
+      rule(text: simple(:text)) do
+        Math::Function::Text.new(text)
+      end
+
       rule(binary: simple(:binary)) do
-        binary.is_a?(Slice) ? Transform.get_class(binary == "over" ? "overset" : binary).new : binary
+        binary.is_a?(String) ? Math::Function::Text.new(binary) : 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
+        Math::Symbol.new(
+          Constants::SYMBOLS[sym.to_sym] || sym,
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           rparen: simple(:rparen)) do
+        Math::Formula.new
+      end
 
-      rule(left_right: simple(:left_right)) do
-        Math::Function::Left.new(left_right)
+      rule(left_right: simple(:left_right),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          left_right,
+          subscript,
+        )
       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),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          left_right,
+          supscript,
+        )
       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: 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(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: 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(text: simple(:text), subscript: simple(:subscript)) do
-        text_object = Math::Function::Text.new(text.to_s)
-        Math::Function::Base.new(text_object, subscript)
+      rule(power: simple(:power),
+           number: simple(:number)) do
+        Math::Function::Power.new(
+          power,
+          Math::Number.new(number),
+        )
       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),
+           dividend: subtree(:dividend),
+           divisor: sequence(:divisor),
+           right: simple(:right),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new(lparen),
+            Math::Function::Over.new(
+              Math::Formula.new(dividend.flatten),
+              Math::Formula.new(divisor),
+            ),
+            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(dividend: subtree(:dividend),
+           divisor: subtree(:divisor)) do
+        Math::Function::Over.new(
+          Math::Formula.new(dividend.flatten),
+          Math::Formula.new(divisor.flatten),
+        )
       end
 
-      rule(sqrt: simple(:sqrt), intermediate_exp: simple(:int_exp)) do
-        Math::Function::Sqrt.new(int_exp)
+      rule(over: simple(:over),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          over,
+          subscript,
+        )
       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(over: simple(:over),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          over,
+          supscript,
+        )
+      end
+
+      rule(operant: simple(:operant),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Symbol.new(operant),
+          subscript,
+        )
       end
 
-      rule(sequence: simple(:sequence), expression: simple(:expr)) do
+      rule(sequence: simple(:sequence),
+           expression: simple(:expr)) do
         [sequence, expr]
       end
 
-      rule(sequence: simple(:sequence), expression: sequence(:expr)) do
+      rule(sequence: simple(:sequence),
+           expression: sequence(:expr)) do
         [sequence] + expr
       end
 
+      rule(unary_functions: simple(:unary),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          unary,
+          subscript,
+        )
+      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,
+          )
+        else
+          Math::Function::FontStyle.new(
+            int_exp,
+            fonts,
+          )
+        end
+      end
+
+      rule(number: simple(:number),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Number.new(number),
+          subscript,
+        )
+      end
+
+      rule(symbols: simple(:sym),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Symbol.new(
+            Constants::SYMBOLS[sym.to_sym] || sym,
+          ),
+          subscript,
+        )
+      end
+
+      rule(symbols: simple(:sym),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Symbol.new(
+            Constants::SYMBOLS[sym.to_sym] || sym,
+          ),
+          supscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Function::Text.new(text),
+          subscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Function::Text.new(text),
+          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,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts,
+                       )
+                     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,
+                       )
+                     else
+                       Utility::FONT_STYLES[fonts.to_sym].new(
+                         int_exp,
+                         fonts,
+                       )
+                     end
+        Math::Function::Base.new(
+          font_style,
+          subscript,
+        )
+      end
+
+      rule(root: simple(:root),
+           first_value: simple(:first_value),
+           second_value: simple(:second_value)) do
+        Math::Function::Root.new(
+          first_value,
+          second_value,
+        )
+      end
+
       rule(unary_functions: simple(:unary),
            base: simple(:base),
            power: simple(:power)) do
-        Plurimath::Math::Function::Limits.new(
-          Transform.get_class(unary).new,
+        Math::Function::Limits.new(
+          Utility.get_class(unary).new,
           base,
           power,
         )
       end
 
       rule(lparen: simple(:lparen),
-           text: simple(:text),
+           mbox: simple(:mbox),
            rparen: simple(:rparen)) do
-        Math::Function::Text.new(text.to_s)
+        Math::Function::Text.new("\\mbox{#{mbox}}")
       end
 
       rule(lparen: simple(:lparen),
-           symbols: simple(:symbol),
+           symbols: simple(:sym),
            rparen: simple(:rparen)) do
-        Math::Symbol.new(symbol.to_s)
-      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)
+        Math::Symbol.new(
+          Constants::SYMBOLS[sym.to_sym] || sym,
         )
       end
 
       rule(lparen: simple(:lparen),
-           sequence: simple(:sequence),
-           expression: sequence(:expr),
+           expression: simple(:expr),
            rparen: simple(:rparen)) do
-        Math::Formula.new([sequence] + expr)
+        expr
       end
 
       rule(lparen: simple(:lparen),
-           sequence: simple(:sequence),
-           expression: simple(:expr),
+           expression: sequence(:expr),
            rparen: simple(:rparen)) do
-        Math::Formula.new([sequence, expr])
+        Math::Formula.new(expr)
       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,
-          )
-        else
-          expr
-        end
+           rparen: simple(:rparen),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Formula.new(expr),
+          supscript,
+        )
       end
 
       rule(lparen: simple(:lparen),
-           expression: sequence(:expr),
-           rparen: simple(:rparen)) do
-        Math::Formula.new(expr)
+           expression: simple(:expr),
+           rparen: simple(:rparen),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          Math::Formula.new(expr),
+          subscript,
+        )
       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)
+        Utility.get_class(binary).new(subscript)
       end
 
       rule(text: simple(:text),
            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::Function::Text.new(text),
+          subscript,
+          supscript,
+        )
+      end
+
+      rule(symbols: simple(:sym),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Math::Symbol.new(
+            Constants::SYMBOLS[sym.to_sym] || sym,
+          ),
+          subscript,
+          supscript,
+        )
       end
 
       rule(binary: simple(:binary),
@@ -180,74 +376,71 @@ 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([first_value]),
+              Math::Function::Tr.new([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.include?("mod") ? "mod" : binary,
+          ).new(
+            first_value,
+            second_value,
+          )
         end
       end
 
       rule(begining: simple(:begining),
            table_data: sequence(:table_data),
            ending: simple(:ending)) do
-        begining.parameter_one = Transform.organize_table(table_data)
-        begining
-      end
-
-      rule(lparen: simple(:lparen),
-           environment: simple(:env),
-           rparen: simple(:rparen)) do
-        env
+        Utility.get_table_class(begining).new(
+          Utility.organize_table(table_data),
+        )
       end
 
       rule(begining: simple(:begining),
            args: simple(:args),
            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
+        Utility.get_table_class(begining).new(
+          Utility.organize_table([table_data]),
+          nil,
+          [args],
+        )
       end
 
       rule(begining: simple(:begining),
            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
+        Utility.get_table_class(begining).new(
+          Utility.organize_table(table_data),
+          nil,
+          args,
+        )
       end
 
       rule(begining: simple(:begining),
            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
+        Utility.get_table_class(begining).new(
+          Utility.organize_table(table_data),
+          nil,
+          [args],
+        )
       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]
+        left_paren = Constants::MATRICES[env.to_sym]
         Math::Function::Table.new(
-          table_value,
+          Utility.organize_table(expr),
           left_paren,
           Constants::PARENTHESIS[left_paren],
         )
@@ -260,39 +453,6 @@ module Plurimath
         formula = Math::Formula.new(expr)
         Math::Function::Power.new(formula, supscript)
       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
-
-        def get_class(text)
-          Object.const_get("Plurimath::Math::Function::#{text.to_s.capitalize}")
-        end
-      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -19,7 +19,7 @@ module Plurimath
 
       def to_mathml
         <<~MATHML
-          <math xmlns='http://www.w3.org/1998/Math/MathML'>
+          <math xmlns='http://www.w3.org/1998/Math/MathML' display='block'>
             <mstyle displaystyle='true'>
               #{mathml_content}
             </mstyle>
@@ -38,6 +38,14 @@ module Plurimath
       def to_latex
         value.map(&:to_latex).join
       end
+
+      def to_html
+        value.map(&:to_html).join
+      end
+
+      def class_name
+        "formula"
+      end
     end
   end
 end

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

@@ -8,7 +8,7 @@ module Plurimath
       class Bar < UnaryFunction
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
-          "\\overline#{first_value}"
+          "\\bar#{first_value}"
         end
       end
     end

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

@@ -20,10 +20,16 @@ module Plurimath
 
         def to_latex
           first_value  = parameter_one.to_latex if parameter_one
-          first_value  = "{#{first_value}}" if parameter_one.is_a?(Math::Formula)
+          first_value  = "{#{first_value}}" if parameter_one.is_a?(Formula)
           second_value = parameter_two.to_latex if parameter_two
           "#{first_value}_{#{second_value}}"
         end
+
+        def to_html
+          first_value  = "<i>#{parameter_one.to_html}</i>" if parameter_one
+          second_value = "<sub>#{parameter_two.to_html}</sub>" if parameter_two
+          "#{first_value}#{second_value}"
+        end
       end
     end
   end