plurimath 0.1.0 → 0.2.0

data/lib/plurimath/latex/parse.rb

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

data/lib/plurimath/latex/parser.rb

@@ -0,0 +1,24 @@
+# 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(" ", "").gsub("\n", "")
+      end
+
+      def parse
+        tree_t = Plurimath::Latex::Parse.new.parse(text)
+        formula = Plurimath::Latex::Transform.new.apply(tree_t)
+        formula = [formula] unless formula.is_a?(Array)
+
+        Plurimath::Math::Formula.new(formula)
+      end
+    end
+  end
+end

data/lib/plurimath/latex/transform.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+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(binary: simple(:binary)) do
+        binary.is_a?(Slice) ? Transform.get_class(binary == "over" ? "overset" : 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(left_right: simple(:left_right)) do
+        Math::Function::Left.new(left_right)
+      end
+
+      rule(fonts: simple(:fonts), intermediate_exp: simple(:int_exp)) do
+        Math::Function::FontStyle.new(int_exp, fonts.to_s)
+      end
+
+      rule(number: simple(:number), subscript: simple(:subscript)) do
+        number_object = Math::Number.new(number.to_s)
+        Math::Function::Base.new(number_object, subscript)
+      end
+
+      rule(symbols: simple(:symbol), subscript: simple(:subscript)) do
+        symbol_object = Math::Symbol.new(symbol.to_s)
+        Math::Function::Base.new(symbol_object, subscript)
+      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)
+      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)
+      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)
+      end
+
+      rule(sqrt: simple(:sqrt), intermediate_exp: simple(:int_exp)) do
+        Math::Function::Sqrt.new(int_exp)
+      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(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),
+           base: simple(:base),
+           power: simple(:power)) do
+        Plurimath::Math::Function::Limits.new(
+          Transform.get_class(unary).new,
+          base,
+          power,
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           text: simple(:text),
+           rparen: simple(:rparen)) do
+        Math::Function::Text.new(text.to_s)
+      end
+
+      rule(lparen: simple(:lparen),
+           symbols: simple(:symbol),
+           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)
+        )
+      end
+
+      rule(lparen: simple(:lparen),
+           sequence: simple(:sequence),
+           expression: sequence(:expr),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([sequence] + expr)
+      end
+
+      rule(lparen: simple(:lparen),
+           sequence: simple(:sequence),
+           expression: simple(:expr),
+           rparen: simple(:rparen)) do
+        Math::Formula.new([sequence, 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
+      end
+
+      rule(lparen: simple(:lparen),
+           expression: sequence(:expr),
+           rparen: simple(:rparen)) do
+        Math::Formula.new(expr)
+      end
+
+      rule(binary: simple(:binary),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Transform.get_class(binary).new(subscript, supscript)
+      end
+
+      rule(binary: simple(:binary),
+           subscript: simple(:subscript)) do
+        Transform.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)
+      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
+          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)
+        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
+      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
+      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
+      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
+      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],
+        )
+      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
+
+      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/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

data/lib/plurimath/math/formula.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Formula
+      attr_accessor :value
+
+      def initialize(value = [])
+        @value = value.is_a?(Array) ? value : [value]
+      end
+
+      def ==(object)
+        object.value == value
+      end
+
+      def to_asciimath
+        value.map(&:to_asciimath).join
+      end
+
+      def to_mathml
+        <<~MATHML
+          <math xmlns='http://www.w3.org/1998/Math/MathML'>
+            <mstyle displaystyle='true'>
+              #{mathml_content}
+            </mstyle>
+          </math>
+        MATHML
+      end
+
+      def to_mathml_without_math_tag
+        "<mrow>#{mathml_content}</mrow>"
+      end
+
+      def mathml_content
+        value.map(&:to_mathml_without_math_tag).join
+      end
+
+      def to_latex
+        value.map(&:to_latex).join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Abs < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Arccos < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Arcsin < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Arctan < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Bar < UnaryFunction
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          "\\overline#{first_value}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Base < BinaryFunction
+        def to_asciimath
+          first_value = parameter_one.to_asciimath if parameter_one
+          second_value = "_#{parameter_two.to_asciimath}" if parameter_two
+          "#{first_value}#{second_value}"
+        end
+
+        def to_mathml_without_math_tag
+          first_value = parameter_one.to_mathml_without_math_tag
+          second_value = parameter_two.to_mathml_without_math_tag
+          "<msub>#{first_value}#{second_value}</msub>"
+        end
+
+        def to_latex
+          first_value  = parameter_one.to_latex if parameter_one
+          first_value  = "{#{first_value}}" if parameter_one.is_a?(Math::Formula)
+          second_value = parameter_two.to_latex if parameter_two
+          "#{first_value}_{#{second_value}}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    module Function
+      class BinaryFunction
+        attr_accessor :parameter_one, :parameter_two
+
+        def initialize(parameter_one = nil, parameter_two = nil)
+          @parameter_one = parameter_one
+          @parameter_two = parameter_two
+        end
+
+        def to_asciimath
+          "#{class_name}#{value_to_asciimath}"
+        end
+
+        def value_to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          second_value = "(#{parameter_two.to_asciimath})" if parameter_two
+          "#{first_value}#{second_value}"
+        end
+
+        def ==(object)
+          object.class == self.class &&
+            object.parameter_one == parameter_one &&
+            object.parameter_two == parameter_two
+        end
+
+        def to_mathml_without_math_tag
+          first_value = parameter_one.to_mathml_without_math_tag if parameter_one
+          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
+          third_value = invert_unicode_symbols.empty? ? class_name : invert_unicode_symbols
+          "<mo>#{third_value}</mo>#{first_value}#{second_value}"
+        end
+
+        def invert_unicode_symbols
+          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name].to_s
+        end
+
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          second_value = "{#{parameter_two.to_latex}}" if parameter_two
+          "\\#{class_name}#{first_value}#{second_value}"
+        end
+
+        def class_name
+          self.class.name.split("::").last.downcase
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Cancel < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Ceil < UnaryFunction
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Color < BinaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one.value if parameter_one
+          second_value = parameter_two.to_mathml_without_math_tag if parameter_two
+          "<mstyle mathcolor='#{first_value}'>#{second_value}</mstyle>"
+        end
+
+        def to_latex
+          first_value = parameter_one.to_latex if parameter_one
+          second_value = parameter_two.to_latex if parameter_two
+          "\\#{class_name}{#{first_value}}#{second_value}"
+        end
+      end
+    end
+  end
+end