plurimath 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80f221bdd7b1327b1773cb34581837b8e1dce2dd869d8908ce6da6c70cd6af33
-  data.tar.gz: abf97a179d3b56a42a36cdeedd5323caf9873125c88cbc1109ecbd32c13be70e
+  metadata.gz: 8c90b0eb8f6510c5a93742653d0a9d395de3adf3b7dfa53f43d53ce4d7821a27
+  data.tar.gz: 966c4a94fc1245cec98e7290e3761be0774a71d62403e38bfa405aa1db5cd9f8
 SHA512:
-  metadata.gz: efa17041d13cb3107a5364777b0cf9cff7e20daf37a885ecf43680a9e9a01d47df2610416042316068fc85a92145aeb888635800994d917dbcb67b91333c2b59
-  data.tar.gz: 9f2af614455c09f6475692431db914ac750dfe405cdf0af4ed38a9dc8e0d6adc7b5d5cf3f2e3e331818b4532c9b4a200f88cdee0ac03e907b2c6fcb26ca994c9
+  metadata.gz: 364d72c3e42db84c13b5896ec36ea4cdb5f856ebdd970e7ff1058f3c2251cb301dd641cb51e1addcb5c890cfbd83cdebc5cf91df48e495704a8eae355b502d82
+  data.tar.gz: 607a1cf277fcbdce40ab130397985e8bf5682662adb747debb42823b257201e110d9aa4d7cb1087a191e98efeadab5976e723c2a9a6f64deb4e38bdf8fa513a1

data/lib/plurimath/latex/constants.rb

@@ -3715,6 +3715,8 @@ module Plurimath
       PARENTHESIS = {
         "[" => "]",
         "(" => ")",
+        "\\(" => "\\)",
+        "\\[" => "\\]",
         "\\{" => "\\}",
       }.freeze
       MATRICES_PARENTHESIS = {
@@ -3783,6 +3785,50 @@ module Plurimath
         bmod
         pmod
       ].freeze
+      LEFT_RIGHT_PARENTHESIS = {
+        "\\backslash": "\",
+        "\\langle": "⟨",
+        "\\rangle": "⟩",
+        "\\lfloor": "⌊",
+        "\\rfloor": "⌋",
+        "\\lceil": "⌈",
+        "\\rceil": "⌉",
+        "\\lbrace": "{",
+        "\\rbrace": "}",
+        "\\lbrack": "[",
+        "\\rbrack": "]",
+        "\\Vert": "‖",
+        "\\vert": "|",
+        "\\|": "‖",
+        "\\}": "}",
+        "\\{": "{",
+        "(": "(",
+        ")": ")",
+        "<": "<",
+        ">": ">",
+        "/": "/",
+        "|": "|",
+        "[": "[",
+        "]": "]",
+      }.freeze
+      SLASHED_SYMBOLS = %w[
+        backslash
+        langle
+        rangle
+        lfloor
+        rfloor
+        lbrace
+        rbrace
+        lbrack
+        rbrack
+        lceil
+        rceil
+        Vert
+        vert
+        |
+        }
+        {
+      ]
     end
   end
 end

data/lib/plurimath/latex/parse.rb

@@ -42,6 +42,14 @@ module Plurimath
         arr_to_expression(Constants::PARENTHESIS.values, :rparen)
       end
 
+      rule(:left_parens) do
+        arr_to_expression(Constants::LEFT_RIGHT_PARENTHESIS.keys, :left_paren)
+      end
+
+      rule(:right_parens) do
+        arr_to_expression(Constants::LEFT_RIGHT_PARENTHESIS.keys, :right_paren)
+      end
+
       rule(:environment) do
         arr_to_expression(Constants::MATRICES.keys, :environment)
       end
@@ -83,13 +91,12 @@ module Plurimath
           match["a-zA-Z"].as(:symbols) |
           match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
           str("\\\\").as("\\\\") >> match(/\s/).repeat |
-          (slash >> (lparen | rparen).as(:symbols)) |
-          lparen |
           str("\\ ").as(:space)
       end
 
       rule(:intermediate_exp) do
-        (str("{") >> expression.maybe.as(:expression) >> str("}")) |
+        (lparen.as(:left_paren) >> expression.maybe.as(:expression) >> rparen.as(:right_paren)).as(:intermediate_exp) |
+          (str("{") >> expression.maybe.as(:expression) >> str("}")) |
           symbol_text_or_integer
       end
 
@@ -123,20 +130,19 @@ module Plurimath
           (begining >> expression.as(:table_data) >> ending).as(:environment) |
           (slash >> environment >> intermediate_exp).as(:table_data) |
           power_base |
-          (rparen >> (base >> sequence.as(:subscript)).maybe >> power >> sequence.as(:supscript)).as(:power_base) |
-          (rparen >> (power >> sequence.as(:supscript)) >> base >> sequence.as(:subscript)).as(:power_base) |
-          rparen |
           intermediate_exp
       end
 
       rule(:left_right) do
         (
-         str("\\left").as(:left) >> lparen.maybe >>
+          str("\\left").as(:left) >> (left_parens | str(".").maybe) >>
+          (
+            (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
+            expression.as(:expression).maybe
+          ) >>
          (
-           (expression.repeat.as(:dividend) >> str("\\over") >> expression.repeat.as(:divisor)) |
-           expression.as(:expression).maybe
-         ) >>
-         str("\\right").as(:right).maybe >> (rparen | str(".").maybe)
+           str("\\right").as(:right).maybe >> (right_parens | str(".").maybe)
+         )
        )
       end
 
@@ -149,14 +155,14 @@ module Plurimath
       end
 
       rule(:iteration) do
-        (sequence.as(:sequence) >> expression.as(:expression)) |
-          sequence
+        (sequence.as(:sequence) >> iteration.as(:expression)) |
+          sequence >> expression.maybe
       end
 
       rule(:expression) do
         (iteration >> expression) |
           iteration |
-          ((iteration.as(:dividend) >> str("\\over") >> iteration.as(:divisor)) >> expression.repeat)
+          ((iteration.as(:dividend) >> str("\\over") >> iteration.as(:divisor)) >> expression.maybe)
       end
 
       root :expression
@@ -208,8 +214,9 @@ module Plurimath
 
       def unary_rules(first_value)
         (slashed_value(first_value, :unary_functions) >> dynamic_power_base) |
-          (slashed_value(first_value, :unary) >> (left_right | intermediate_exp).as(:first_value)).as(:unary_functions) |
-          (slashed_value(first_value, :unary))
+          (slashed_value(first_value, :unary) >> left_right.as(:first_value)).as(:unary_functions) |
+          (slashed_value(first_value, :unary) >> intermediate_exp.as(:first_value)).as(:unary_functions) |
+          slashed_value(first_value, :unary)
       end
 
       def dynamic_power_base

data/lib/plurimath/latex/transform.rb

@@ -24,6 +24,8 @@ module Plurimath
       rule(power_base: simple(:power_base)) { power_base }
       rule(table_data: simple(:table_data)) { table_data }
 
+      rule(intermediate_exp: simple(:int_exp)) { int_exp }
+
       rule(numeric_values: simple(:value)) do
         Math::Symbol.new(value)
       end
@@ -72,57 +74,107 @@ module Plurimath
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: sequence(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            Math::Formula.new(expr),
+            Utility.left_right_objects(rparen, "right"),
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
+           expression: sequence(:expr),
+           right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Formula.new(expr),
-            Math::Function::Right.new(rparen),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            expr,
+            Math::Function::Right.new,
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Function::Right.new,
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(lparen, "left"),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen)) do
-        Math::Function::Left.new(lparen)
+           left_paren: simple(:lparen)) do
+        Utility.left_right_objects(lparen, "left")
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            expression: simple(:expr),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
+        Math::Formula.new(
+          [
+            Utility.left_right_objects(lparen, "left"),
+            expr,
+            Utility.left_right_objects(rparen, "right"),
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           expression: simple(:expr),
+           right: simple(:right)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Math::Function::Left.new,
             expr,
-            Math::Function::Right.new(rparen),
+            Math::Function::Right.new,
+          ],
+        )
+      end
+
+      rule(left: simple(:left),
+           expression: sequence(:expr),
+           right: simple(:right)) do
+        Math::Formula.new(
+          [
+            Math::Function::Left.new,
+            Math::Formula.new(expr),
+            Math::Function::Right.new,
           ],
         )
       end
@@ -168,14 +220,14 @@ module Plurimath
       end
 
       rule(left: simple(:left),
-           lparen: simple(:lparen),
+           left_paren: simple(:lparen),
            dividend: subtree(:dividend),
            divisor: subtree(:divisor),
            right: simple(:right),
-           rparen: simple(:rparen)) do
+           right_paren: simple(:rparen)) do
         Math::Formula.new(
           [
-            Math::Function::Left.new(lparen),
+            Utility.left_right_objects(lparen, "left"),
             Math::Function::Over.new(
               Math::Formula.new(
                 Array(dividend).flatten,
@@ -184,7 +236,7 @@ module Plurimath
                 Array(divisor).flatten,
               ),
             ),
-            Math::Function::Right.new(rparen),
+            Utility.left_right_objects(rparen, "right"),
           ],
         )
       end
@@ -333,6 +385,14 @@ module Plurimath
         )
       end
 
+      rule(intermediate_exp: simple(:int_exp),
+           supscript: simple(:supscript)) do
+        Math::Function::Power.new(
+          int_exp,
+          supscript,
+        )
+      end
+
       rule(unicode_symbols: simple(:sym),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
@@ -451,6 +511,26 @@ module Plurimath
         Math::Formula.new(expr)
       end
 
+      rule(left_paren: simple(:lparen),
+           expression: simple(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          [expr],
+          rparen,
+        )
+      end
+
+      rule(left_paren: simple(:lparen),
+           expression: sequence(:expr),
+           right_paren: simple(:rparen)) do
+        Math::Function::Fenced.new(
+          lparen,
+          expr,
+          rparen,
+        )
+      end
+
       rule(expression: sequence(:expr)) do
         Math::Formula.new(expr)
       end

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

@@ -35,7 +35,7 @@ module Plurimath
           close_paren  = parameter_three ? parameter_three.value : ")"
           first_value  = latex_paren(open_paren, false)
           second_value = latex_paren(close_paren, true)
-          "#{first_value}#{fenced_value}#{second_value}"
+          "#{first_value} #{fenced_value} #{second_value}"
         end
 
         def to_omml_without_math_tag
@@ -96,11 +96,10 @@ module Plurimath
         end
 
         def latex_paren(paren, right)
-          paren_side = right ? "\\right" : "\\left"
-          return "#{paren_side} ." if paren&.include?(":")
+          return "" if paren.nil? || paren.empty?
 
           paren = %w[{ }].include?(paren) ? "\\#{paren}" : paren
-          " #{paren_side} #{paren} "
+          "#{paren}"
         end
 
         def mathml_paren(field)

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

@@ -27,8 +27,7 @@ module Plurimath
         end
 
         def to_latex
-          prefix = "\\" if parameter_one == "{"
-          "\\left #{prefix}#{parameter_one}"
+          "\\left #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || "."}"
         end
 
         protected

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

@@ -27,8 +27,7 @@ module Plurimath
         end
 
         def to_latex
-          prefix = "\\" if parameter_one == "}"
-          "\\right #{prefix}#{parameter_one}"
+          "\\right #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || "."}"
         end
 
         protected

data/lib/plurimath/utility.rb

@@ -407,6 +407,15 @@ module Plurimath
           end
         end
       end
+
+      def left_right_objects(paren, function)
+        paren = if paren.to_s.match?(/\\{|\\}/)
+                  paren.to_s.gsub(/\\/, "")
+                else
+                  Latex::Constants::LEFT_RIGHT_PARENTHESIS[paren.to_sym]
+                end
+        get_class(function).new(paren)
+      end
     end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-09 00:00:00.000000000 Z
+date: 2023-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet