plurimath 0.1.0 → 0.2.1

data/lib/plurimath/latex/parse.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Plurimath
+  class Latex
+    class Parse < Parslet::Parser
+      rule(:base)   { str("_") }
+      rule(:power)  { str("^") }
+      rule(:slash)  { str("\\") }
+      rule(:unary)  { slash >> unary_classes }
+      rule(:ending) { (slash >> str("end") >> intermediate_exp).as(:ending) }
+      rule(:binary) { slash >> binary_classes }
+
+      rule(:array_args) { (str("{") >> expression >> str("}")).as(:args) }
+      rule(:under_over) { slash >> underover_classes }
+
+      rule(:begining) do
+        (slash >> str("begin") >> intermediate_exp).as(:begining)
+      end
+
+      rule(:symbols) do
+        arr_to_expression(Constants::SYMBOLS.keys, :symbols)
+      end
+
+      rule(:operators) do
+        arr_to_expression(Constants::OPERATORS, :operant)
+      end
+
+      rule(:numeric_values) do
+        arr_to_expression(Constants::NUMERIC_VALUES, :numeric_values)
+      end
+
+      rule(:unary_classes) do
+        arr_to_expression(Constants::UNARY_CLASSES, :unary)
+      end
+
+      rule(:binary_classes) do
+        arr_to_expression(Constants::BINARY_CLASSES, :binary)
+      end
+
+      rule(:underover_classes) do
+        arr_to_expression(Constants::UNDEROVER_CLASSES, :binary)
+      end
+
+      rule(:power_base_classes) do
+        arr_to_expression(Constants::POWER_BASE_CLASSES, :binary)
+      end
+
+      rule(:math_operators_classes) do
+        arr_to_expression(Constants::MATH_OPERATORS, :unary_functions)
+      end
+
+      rule(:lparen) do
+        arr_to_expression(Constants::PARENTHESIS.keys, :lparen)
+      end
+
+      rule(:rparen) do
+        arr_to_expression(Constants::PARENTHESIS.values, :rparen)
+      end
+
+      rule(:subscript) do
+        intermediate_exp >> base >> intermediate_exp.as(:subscript)
+      end
+
+      rule(:supscript) do
+        intermediate_exp >> power >> intermediate_exp.as(:supscript)
+      end
+
+      rule(:environment) do
+        arr_to_expression(Constants::MATRICES.keys, :environment)
+      end
+
+      rule(:fonts) do
+        arr_to_expression(Constants::FONT_STYLES, :fonts)
+      end
+
+      rule(:math_operators) do
+        slash >> math_operators_classes >> str("\\limits")
+      end
+
+      rule(:left_right) do
+        (str("\\left").as(:left) >> lparen >> expression.as(:expression) >> str("\\right").as(:right) >> rparen)
+      end
+
+      rule(:sqrt_arg) do
+        str("[").as(:lparen) >> (expression | str("")) >> str("]").as(:rparen)
+      end
+
+      rule(:limits) do
+        (math_operators >> base >> intermediate_exp.as(:base) >> power >> intermediate_exp.as(:power)) |
+          (math_operators >> power >> intermediate_exp.as(:power) >> base >> intermediate_exp.as(:base))
+      end
+
+      rule(:symbol_class_commands) do
+        (slash >> symbols) |
+          (unary >> intermediate_exp.as(:first_value)).as(:unary_functions) |
+          unary.as(:unary_functions) |
+          binary |
+          under_over |
+          environment |
+          operators |
+          numeric_values |
+          (slash >> power_base_classes) |
+          (slash >> fonts >> (binary_functions | intermediate_exp).as(:intermediate_exp))
+      end
+
+      rule(:symbol_text_or_integer) do
+        symbol_class_commands |
+          match["a-zA-Z"].repeat(1).as(:text) |
+          (str('"') >> match("[^\"]").repeat >> str('"')).as(:text) |
+          match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
+          str("\\\\").as("\\\\")
+      end
+
+      rule(:intermediate_exp) do
+        (lparen >> expression.as(:expression) >> rparen) |
+          (lparen >> str("") >> rparen) |
+          symbol_text_or_integer
+      end
+
+      rule(:power_base) do
+        (subscript >> power >> intermediate_exp.as(:supscript)).as(:power_base) |
+          (supscript >> base >> intermediate_exp.as(:subscript)).as(:power_base) |
+          supscript.as(:power) |
+          subscript.as(:base)
+      end
+
+      rule(:binary_functions) do
+        (slash >> str("sqrt").as(:root) >> sqrt_arg.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary) |
+          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary) |
+          (intermediate_exp.as(:first_value) >> under_over >> intermediate_exp.as(:second_value)).as(:under_over) |
+          (binary >> intermediate_exp.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary)
+      end
+
+      rule(:sequence) do
+        limits.as(:limits) |
+          (left_right.as(:left_right) >> power >> intermediate_exp.as(:supscript)) |
+          (left_right.as(:left_right) >> base >> intermediate_exp.as(:subscript)) |
+          left_right.as(:left_right) |
+          (over_class >> power >> intermediate_exp.as(:supscript)) |
+          (over_class >> base >> intermediate_exp.as(:subscript)) |
+          over_class |
+          (slash >> str("mbox") >> lparen.capture(:paren) >> read_text >> rparen).as(:unary_functions) |
+          (slash >> str("substack").as(:substack) >> lparen >> expression.as(:substack_value) >> rparen) |
+          (begining >> array_args >> expression.as(:table_data) >> ending).as(:environment) |
+          (begining >> expression.as(:table_data) >> ending).as(:environment) |
+          (slash >> environment >> intermediate_exp).as(:table_data) |
+          power_base |
+          binary_functions |
+          intermediate_exp
+      end
+
+      rule(:left_right_over) do
+        (str("\\left").as(:left) >>
+          lparen >>
+          expression.repeat.as(:dividend) >>
+          str("\\over") >>
+          expression.repeat.as(:divisor) >>
+          str("\\right").as(:right) >>
+          rparen)
+      end
+
+      rule(:over_class) do
+        (
+          (str("{") >> expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor) >> str("}")) |
+          (left_right_over.as(:left_right).as(:power) >> power >> intermediate_exp) |
+          (left_right_over.as(:left_right).as(:base) >> base >> intermediate_exp) |
+          left_right_over.as(:left_right)
+        ).as(:over)
+      end
+
+      rule(:iteration) do
+        (sequence.as(:sequence) >> expression.as(:expression)) | sequence
+      end
+
+      rule(:expression) { (iteration >> expression) | iteration }
+
+      root :expression
+
+      def arr_to_expression(array, name = nil)
+        type = array.first.class
+        array.reduce do |expression, expr_string|
+          name = name || expr_string.to_sym || expression.to_sym
+          expression = str(expression).as(name) if expression.is_a?(type)
+          expression | str(expr_string).as(name)
+        end
+      end
+
+      def read_text
+        dynamic do |_sour, context|
+          lparen = context.captures[:paren][:lparen].to_s
+          rparen = Constants::PARENTHESIS[lparen]
+          match("[^#{rparen}]").repeat.as(:mbox)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/latex/parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "parse"
+require_relative "constants"
+require_relative "transform"
+module Plurimath
+  class Latex
+    class Parser
+      attr_accessor :text
+
+      def initialize(text)
+        @text = text.gsub(/\s/, "")
+      end
+
+      def parse
+        tree_t = Latex::Parse.new.parse(text)
+        tree_t = JSON.parse(tree_t.to_json, symbolize_names: true)
+        formula = Latex::Transform.new.apply(tree_t)
+        formula = [formula] unless formula.is_a?(Array)
+
+        Math::Formula.new(formula)
+      end
+    end
+  end
+end

data/lib/plurimath/latex/transform.rb

@@ -0,0 +1,458 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Latex
+    class Transform < Parslet::Transform
+      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?(String) ? Math::Function::Text.new(binary) : binary
+      end
+
+      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),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          left_right,
+          subscript,
+        )
+      end
+
+      rule(left_right: simple(:left_right),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          left_right,
+          supscript,
+        )
+      end
+
+      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(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(power: simple(:power),
+           number: simple(:number)) do
+        Math::Function::Power.new(
+          power,
+          Math::Number.new(number),
+        )
+      end
+
+      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(dividend: subtree(:dividend),
+           divisor: subtree(:divisor)) do
+        Math::Function::Over.new(
+          Math::Formula.new(dividend.flatten),
+          Math::Formula.new(divisor.flatten),
+        )
+      end
+
+      rule(over: simple(:over),
+           subscript: simple(:subscript)) do
+        Math::Function::Base.new(
+          over,
+          subscript,
+        )
+      end
+
+      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
+        [sequence, expr]
+      end
+
+      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
+        Math::Function::Limits.new(
+          Utility.get_class(unary).new,
+          base,
+          power,
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           mbox: simple(:mbox),
+           rparen: simple(:rparen)) do
+        Math::Function::Text.new("\\mbox{#{mbox}}")
+      end
+
+      rule(lparen: simple(:lparen),
+           symbols: simple(:sym),
+           rparen: simple(:rparen)) do
+        Math::Symbol.new(
+          Constants::SYMBOLS[sym.to_sym] || sym,
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           expression: simple(:expr),
+           rparen: simple(:rparen)) do
+        expr
+      end
+
+      rule(lparen: simple(:lparen),
+           expression: sequence(:expr),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(expr)
+      end
+
+      rule(lparen: simple(:lparen),
+           expression: simple(:expr),
+           rparen: simple(:rparen),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          Math::Formula.new(expr),
+          supscript,
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           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
+        Utility.get_class(binary).new(
+          subscript,
+          supscript,
+        )
+      end
+
+      rule(binary: simple(:binary),
+           subscript: simple(:subscript)) do
+        Utility.get_class(binary).new(subscript)
+      end
+
+      rule(text: simple(:text),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        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),
+           first_value: simple(:first_value),
+           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]),
+            ],
+            "(",
+            ")",
+          )
+        else
+          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
+        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
+        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
+        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
+        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
+        left_paren = Constants::MATRICES[env.to_sym]
+        Math::Function::Table.new(
+          Utility.organize_table(expr),
+          left_paren,
+          Constants::PARENTHESIS[left_paren],
+        )
+      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)
+      end
+    end
+  end
+end

data/lib/plurimath/latex.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Latex
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_formula
+      Parser.new(text).parse
+    end
+  end
+end