plurimath 0.9.2 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e88ad9f1e0f653ba649b18558767f46e2aff74f317875248370f6df63d1f5939
-  data.tar.gz: 06d6b2d10f0874ff134ec1879d40cd507030d2115a4a5961c1259435db160493
+  metadata.gz: 25137b188abdff732f47c221a2b04e8a5861cd2d642e8496176ff77c6d991f72
+  data.tar.gz: b1a9c2180b99f077a0c77293785b5b11a5ea76a6b5b1dc35328b6456e1c7664d
 SHA512:
-  metadata.gz: 606a945c8a2d9d30e242162f0bff29db50eed474f6b527b746f61d3ba7937e602e0033cfec81e92c604e49b0424c1ed0c7546ef9f77bd46d19d1c0ce59b09107
-  data.tar.gz: 434c78d3b2731056f5ed0d94342c18acda6b4c3f851a225978139ce91cf1fd53b2e091569e1c0c61f0aea865817bcd99126eeae6578e6a83c74ae120ed9b1b69
+  metadata.gz: e1ecd1523941d106ab5f5903e874a689ae2ee3a74f0cc002fe0e346451f45d339ed83c7bb330af8897770280a3859047809cf6e55b05d738f1953fb1e1ab2ccb
+  data.tar.gz: 22b67912e8b99d1ceab2e09b50da7638cfca8d329279ddbcc97174cd5beba8315c23802cc99701b80f41cc64b42bd428fff3bed8f081c3900ec6b489061f5c60

data/lib/plurimath/asciimath/parse.rb

@@ -65,7 +65,7 @@ module Plurimath
       rule(:left_right) do
         (str("left") >> space? >> left_right_open_paren.as(:left) >> space? >> (iteration.maybe >> sequence.maybe).as(:left_right_value) >> space? >> str("right") >> space? >> left_right_close_paren.as(:right)) |
           ((table.as(:numerator) >> space? >> match(/(?<!\/)\/(?!\/)/) >> space? >> iteration.as(:denominator)).as(:frac) >> expression) |
-          (table.as(:table) >> expression.maybe)
+          (table.as(:table) >> power_base.maybe >> expression.maybe)
       end
 
       rule(:quoted_text) do
@@ -138,7 +138,7 @@ module Plurimath
 
       rule(:iteration) do
         ternary_classes_rules |
-          table.as(:table) |
+          table.as(:table) >> power_base.maybe |
           comma.as(:comma) |
           mod |
           (sequence.as(:sequence) >> space? >> str("//").as(:symbol)) |

data/lib/plurimath/asciimath/transform.rb

@@ -900,6 +900,64 @@ module Plurimath
         Math::Formula.new(formula_array)
       end
 
+      rule(table: simple(:table),
+           base: simple(:base)) do
+        Math::Function::Base.new(table, base)
+      end
+
+      rule(table: simple(:table),
+           power: simple(:power)) do
+        Math::Function::Power.new(table, power)
+      end
+
+      rule(table: simple(:table),
+           power_value: simple(:power),
+           base_value: simple(:base)) do
+        Math::Function::PowerBase.new(table, power, base)
+      end
+
+      rule(table: simple(:table),
+           power: simple(:power),
+           expr: sequence(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::Power.new(table, power),
+          ] + expr.flatten.compact,
+        )
+      end
+
+      rule(table: simple(:table),
+           power: simple(:power),
+           expr: simple(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::Power.new(table, power),
+            expr,
+          ],
+        )
+      end
+
+      rule(table: simple(:table),
+           base: simple(:base),
+           expr: sequence(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::Base.new(table, base),
+          ] + expr.flatten.compact,
+        )
+      end
+
+      rule(table: simple(:table),
+           base: simple(:base),
+           expr: simple(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::Base.new(table, base),
+            expr,
+          ],
+        )
+      end
+
       rule(table: simple(:table),
            rparen: simple(:rparen),
            expr: sequence(:expr)) do
@@ -1032,6 +1090,29 @@ module Plurimath
         )
       end
 
+      rule(table: simple(:table),
+           power_value: simple(:power),
+           base_value: simple(:base),
+           expr: simple(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::PowerBase.new(table, power, base),
+            expr,
+          ],
+        )
+      end
+
+      rule(table: simple(:table),
+           power_value: simple(:power),
+           base_value: simple(:base),
+           expr: sequence(:expr)) do
+        Math::Formula.new(
+          [
+            Math::Function::PowerBase.new(table, power, base),
+          ] + expr.flatten.compact,
+        )
+      end
+
       rule(table_left: simple(:table_left),
            table_row: simple(:table_row),
            expr: simple(:expr),

data/lib/plurimath/formatter/numbers/fraction.rb

@@ -18,8 +18,12 @@ module Plurimath
           precision = options[:precision] || @precision
           return "" unless precision > 0
 
-          number = format(fraction, precision)
-          number = digit_count_format(int, fraction, number) if @digit_count
+          number = if @digit_count
+                     digit_count_format(int, fraction)
+                   else
+                     format(fraction, precision)
+                   end
+
           formatted_number = change_format(number) if number
           formatted_number ? decimal + formatted_number : ""
         end
@@ -40,18 +44,17 @@ module Plurimath
           tokens.compact.join(separator)
         end
 
-        def digit_count_format(int, fraction, number)
+        def digit_count_format(int, fraction)
           integer = int + "." + fraction
-          float = BigDecimal(integer)
-          int_length = integer.length - 1
+          int_length = integer.length - 1 # integer length; excluding the decimal point
           @digit_count ||= int_length
           if int_length > @digit_count
-            number_string = float.round(@digit_count - int.length)
+            number_string = BigDecimal(integer).round(@digit_count - int.length)
             numeric_digits(number_string) if @digit_count > int.length
           elsif int_length < @digit_count
-            number + "0" * (update_digit_count(number) - int_length)
+            fraction + ("0" * (update_digit_count(fraction) - int_length))
           else
-            number
+            fraction
           end
         end
 

data/lib/plurimath/formatter/numbers/significant.rb

@@ -33,9 +33,9 @@ module Plurimath
           frac_part = false
           new_chars = []
           sig_count = significant
-          chars.each.with_index do |char, ind|
-            frac_part = frac_part || char == decimal
-            sig_num = sig_num || char.match?(/[1-9]/)
+          chars.each_with_index do |char, ind|
+            frac_part ||= char == decimal
+            sig_num ||= char.match?(/[1-9]/)
             break if sig_count.zero?
 
             new_chars << char
@@ -47,7 +47,6 @@ module Plurimath
 
           if sig_count > 0
             new_chars << decimal unless frac_part
-            new_chars << ("0" * sig_count)
           else
             remain_chars = count_chars(chars, frac_part) - significant
             if remain_chars > 0
@@ -66,7 +65,7 @@ module Plurimath
 
           frac_part = false if chars[arr_len] == decimal
           prev_ten  = false
-          array.reverse!.each.with_index do |char, ind|
+          array.reverse!.each_with_index do |char, ind|
             if char == decimal
               array[ind] = ""
               frac_part  = false

data/lib/plurimath/latex/transform.rb

@@ -183,6 +183,14 @@ module Plurimath
         )
       end
 
+      rule(power: simple(:power),
+           symbols: simple(:sym)) do
+        Math::Function::Power.new(
+          power,
+          Utility.symbols_class(sym, lang: :latex),
+        )
+      end
+
       rule(power: simple(:power),
            expression: simple(:expr)) do
         Math::Function::Power.new(

data/lib/plurimath/math/core.rb

@@ -30,7 +30,7 @@ module Plurimath
       end
 
       def insert_t_tag(display_style, options:)
-        Array(to_omml_without_math_tag(display_style, options: options))
+        Array(omml_nodes(display_style, options: options))
       end
 
       def tag_name
@@ -72,14 +72,17 @@ module Plurimath
       def r_element(string, rpr_tag: true)
         r_tag = ox_element("r", namespace: "m")
         if rpr_tag
-          attrs = { "m:val": "p" }
-          sty_tag = ox_element("sty", namespace: "m", attributes: attrs)
-          r_tag << (ox_element("rPr", namespace: "m") << sty_tag)
+          r_tag << (ox_element("rPr", namespace: "m") << msty_tag_with_attrs)
         end
         r_tag << (ox_element("t", namespace: "m") << string)
         Array(r_tag)
       end
 
+      def msty_tag_with_attrs
+        attrs = { "m:val": "p" }
+        ox_element("sty", namespace: "m", attributes: attrs)
+      end
+
       def extractable?
         false
       end
@@ -89,7 +92,7 @@ module Plurimath
       end
 
       def font_style_t_tag(display_style, options:)
-        to_omml_without_math_tag(display_style, options: options)
+        omml_nodes(display_style, options: options)
       end
 
       def ascii_fields_to_print(field, options = {})
@@ -144,7 +147,7 @@ module Plurimath
       end
 
       def dump_mathml(field, intent = false, options:)
-        dump_ox_nodes(field.to_mathml_without_math_tag(intent, options: options)).gsub(/\n\s*/, "")
+        dump_ox_nodes(field.mathml_nodes(intent, options: options)).gsub(/\n\s*/, "")
       end
 
       def dump_omml(field, display_style, options:)
@@ -153,15 +156,19 @@ module Plurimath
         dump_ox_nodes(field.omml_nodes(display_style, options: options)).gsub(/\n\s*/, "")
       end
 
+      def mathml_nodes(intent, options:)
+        to_mathml_without_math_tag(intent, options: options)
+      end
+
       def omml_nodes(display_style, options:)
         to_omml_without_math_tag(display_style, options: options)
       end
 
       def validate_mathml_fields(field, intent, options:)
         if field.is_a?(Array)
-          field&.map { |object| object.to_mathml_without_math_tag(intent, options: options) }
+          field&.map { |object| object.mathml_nodes(intent, options: options) }
         else
-          field&.to_mathml_without_math_tag(intent, options: options)
+          field&.mathml_nodes(intent, options: options)
         end
       end
 

data/lib/plurimath/math/formula.rb

@@ -9,20 +9,29 @@ module Plurimath
 
       attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string, :display
 
-      MATH_ZONE_TYPES = %i[
-        omml
-        latex
-        mathml
-        asciimath
-        unicodemath
-      ].freeze
       POWER_BASE_CLASSES = %w[powerbase power base].freeze
-      DERIVATIVE_CONSTS = [
-        "𝑑",
-        "ⅅ",
-        "ⅆ",
-        "d",
-      ].freeze
+      DERIVATIVE_CONSTS  = ["𝑑", "ⅅ", "ⅆ", "d"].freeze
+      MATH_ZONE_TYPES    = %i[omml latex mathml asciimath unicodemath].freeze
+      OMML_NAMESPACES    = {
+        "xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+        "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+        "xmlns:mo": "http://schemas.microsoft.com/office/mac/office/2008/main",
+        "xmlns:mv": "urn:schemas-microsoft-com:mac:vml",
+        "xmlns:o": "urn:schemas-microsoft-com:office:office",
+        "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+        "xmlns:v": "urn:schemas-microsoft-com:vml",
+        "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+        "xmlns:w10": "urn:schemas-microsoft-com:office:word",
+        "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+        "xmlns:w15": "http://schemas.microsoft.com/office/word/2012/wordml",
+        "xmlns:wne": "http://schemas.microsoft.com/office/word/2006/wordml",
+        "xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+        "xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+        "xmlns:wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
+        "xmlns:wpg": "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
+        "xmlns:wpi": "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
+        "xmlns:wps": "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
+      }.freeze
 
       def initialize(
         value = [],
@@ -55,9 +64,14 @@ module Plurimath
         formatter: nil,
         unitsml: {},
         split_on_linebreak: false,
-        display_style: displaystyle
+        display_style: displaystyle,
+        unary_function_spacing: true
       )
-        options = { formatter: formatter, unitsml: unitsml }.compact
+        options = {
+          formatter: formatter,
+          unitsml: unitsml,
+          unary_function_spacing: unary_function_spacing
+        }.compact
         return line_breaked_mathml(display_style, intent, options: options) if split_on_linebreak
 
         math_attrs = {
@@ -77,7 +91,12 @@ module Plurimath
 
       def line_breaked_mathml(display_style, intent, options:)
         new_line_support.map do |formula|
-          formula.to_mathml(display_style: display_style, intent: intent, formatter: options[:formatter])
+          formula.to_mathml(
+            display_style: display_style,
+            intent: intent,
+            formatter: options[:formatter],
+            unary_function_spacing: options[:unary_function_spacing],
+          )
         end.join
       end
 
@@ -110,33 +129,10 @@ module Plurimath
         parse_error!(:html)
       end
 
-      def omml_attrs
-        {
-          "xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
-          "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
-          "xmlns:mo": "http://schemas.microsoft.com/office/mac/office/2008/main",
-          "xmlns:mv": "urn:schemas-microsoft-com:mac:vml",
-          "xmlns:o": "urn:schemas-microsoft-com:office:office",
-          "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-          "xmlns:v": "urn:schemas-microsoft-com:vml",
-          "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-          "xmlns:w10": "urn:schemas-microsoft-com:office:word",
-          "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
-          "xmlns:w15": "http://schemas.microsoft.com/office/word/2012/wordml",
-          "xmlns:wne": "http://schemas.microsoft.com/office/word/2006/wordml",
-          "xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
-          "xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
-          "xmlns:wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
-          "xmlns:wpg": "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
-          "xmlns:wpi": "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
-          "xmlns:wps": "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
-        }
-      end
-
       def to_omml(display_style: displaystyle, split_on_linebreak: false, formatter: nil, unitsml: {})
         objects = split_on_linebreak ? new_line_support : [self]
         options = { formatter: formatter, unitsml: unitsml }.compact
-        para_element = Utility.ox_element("oMathPara", attributes: omml_attrs, namespace: "m")
+        para_element = Utility.ox_element("oMathPara", attributes: OMML_NAMESPACES, namespace: "m")
         objects.each.with_index(1) do |object, index|
           para_element << Utility.update_nodes(
             Utility.ox_element("oMath", namespace: "m"),
@@ -166,8 +162,12 @@ module Plurimath
         parse_error!(:unicodemath)
       end
 
-      def to_display(type = nil, formatter: nil, unitsml: {})
-        options = { formatter: formatter, unitsml: unitsml }
+      def to_display(type = nil, formatter: nil, unitsml: {}, unary_function_spacing: true)
+        options = {
+          formatter: formatter,
+          unitsml: unitsml,
+          unary_function_spacing: unary_function_spacing
+        }
         return type_error!(type) unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
 
         math_zone = case type
@@ -176,7 +176,7 @@ module Plurimath
                     when :latex
                       "  |_ \"#{to_latex(options: options)}\"\n#{to_latex_math_zone("     ", options: options).join}"
                     when :mathml
-                      mathml = to_mathml(formatter: formatter).gsub(/\n\s*/, "")
+                      mathml = to_mathml(formatter: formatter, unary_function_spacing: options[:unary_function_spacing]).gsub(/\n\s*/, "")
                       math_display = to_mathml_math_zone("     ", options: options).join
                       "  |_ \"#{mathml}\"\n#{math_display}"
                     when :omml
@@ -628,7 +628,7 @@ module Plurimath
         insert_index = 0
         nodes.each.with_index do |node, index|
           if node[:unitsml]
-            prev_node.insert_in_nodes(index + insert_index, space_element(node))
+            prev_node.insert_in_nodes(index + insert_index, space_element)
             insert_index += 1
             node.remove_attr("unitsml")
           end
@@ -636,7 +636,7 @@ module Plurimath
         end
       end
 
-      def space_element(node)
+      def space_element
         element = (ox_element("mo") << "&#x2062;")
         element[:rspace] = "thickmathspace"
         element

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

@@ -92,9 +92,7 @@ module Plurimath
         end
 
         def rpr_tag
-          sty_atrs = { "m:val": "p" }
-          sty_tag  = Utility.ox_element("sty", attributes: sty_atrs, namespace: "m")
-          rpr_tag  = (Utility.ox_element("rPr", namespace: "m") << sty_tag)
+          rpr_tag  = (Utility.ox_element("rPr", namespace: "m") << msty_tag_with_attrs)
           r_tag = Utility.ox_element("r", namespace: "m")
           t_tag = (Utility.ox_element("t", namespace: "m") << "log")
           Utility.update_nodes(r_tag, [rpr_tag, t_tag])

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

@@ -12,8 +12,14 @@ module Plurimath
 
         PARSER_REGEX = %r{unicode\[:(?<unicode>\w{1,})\]}.freeze
 
-        def initialize(parameter_one = "")
+        def initialize(parameter_one = "", lang: nil)
           super(parameter_one)
+          @lang = lang
+        end
+
+        def ==(object)
+          object.class == self.class &&
+            object.parameter_one == self.parameter_one
         end
 
         def to_asciimath(**)
@@ -50,7 +56,15 @@ module Plurimath
 
         def insert_t_tag(display_style, options:)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style, options: options))
+          if @lang&.to_s != "omml"
+            rpr_tag = Utility.ox_element("rPr", namespace: "m")
+            rpr_tag << msty_tag_with_attrs
+            r_tag << rpr_tag
+          end
+          Utility.update_nodes(
+            r_tag,
+            [omml_nodes(display_style, options: options)],
+          )
           [r_tag]
         end
 

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

@@ -28,16 +28,32 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag(intent, options:)
-          tag_name = Utility::UNARY_CLASSES.include?(class_name) ? "mi" : "mo"
+          tag_name = if Utility::UNARY_CLASSES.include?(class_name)
+                       insert_space_tags = true
+                       "mi"
+                     else
+                       "mo"
+                     end
           new_arr = []
           new_arr << (ox_element(tag_name) << class_name) unless hide_function_name
-          if parameter_one
-            new_arr += mathml_value(intent, options: options)
-            mrow = ox_element("mrow")
-            Utility.update_nodes(mrow, new_arr)
-            intentify(mrow, intent, func_name: :function, intent_name: intent_names[:name])
+          unary_element = if parameter_one
+                            new_arr += mathml_value(intent, options: options)
+                            mrow = ox_element("mrow")
+                            Utility.update_nodes(mrow, new_arr)
+                            intentify(mrow, intent, func_name: :function, intent_name: intent_names[:name])
+                          else
+                            new_arr.first
+                          end
+          if insert_space_tags && options[:unary_function_spacing]
+            Utility.update_nodes(
+              ox_element("mrow"),
+              [
+                ox_element("mo", attributes: { rspace: "thickmathspace" }),
+                unary_element,
+              ],
+            )
           else
-            new_arr.first
+            unary_element
           end
         end
 

data/lib/plurimath/omml/transform.rb

@@ -15,6 +15,7 @@ module Plurimath
       rule(sty: simple(:sty))    { sty }
       rule(num: subtree(:num))   { num }
       rule(den: subtree(:den))   { den }
+      rule(nor: subtree(:nor))   { nil }
       rule(fPr: subtree(:fPr))   { nil }
       rule(mpr: subtree(:mpr))   { nil }
       rule(mPr: subtree(:mPr))   { nil }
@@ -88,7 +89,7 @@ module Plurimath
 
       rule(t: sequence(:t)) do
         if t.empty?
-          Math::Function::Text.new
+          Math::Function::Text.new("", lang: :omml)
         else
           t&.compact&.empty? ? [nil] : Utility.mathml_unary_classes(t, omml: true, lang: :omml)
         end

data/lib/plurimath/utility.rb

@@ -361,7 +361,7 @@ module Plurimath
         if text&.scan(/[[:digit:]]/)&.length == text&.length
           Math::Number.new(text)
         elsif text&.match?(/[a-zA-Z]/)
-          Math::Function::Text.new(text)
+          Math::Function::Text.new(text, lang: lang)
         else
           text = string_to_html_entity(text)
                   .gsub("&", "&")
@@ -481,7 +481,7 @@ module Plurimath
           [
             Math::Function::Intent.new(
               filter_values(join_attr_value(nil, value, unicode_only: unicode_only, lang: lang)),
-              Math::Function::Text.new(attrs[:intent]),
+              Math::Function::Text.new(attrs[:intent], lang: lang),
             )
           ]
         elsif value.any?(String)
@@ -767,11 +767,11 @@ module Plurimath
             next temp_array << (object.is_a?(Math::Symbols::Symbol) ? symbol_to_text(object, lang: lang, intent: intent, options: options) : object.value)
           end
 
-          new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+          new_arr << Math::Function::Text.new(temp_array.join(" "), lang: lang) if temp_array.any?
           temp_array = []
           new_arr << object
         end
-        new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+        new_arr << Math::Function::Text.new(temp_array.join(" "), lang: lang) if temp_array.any?
         new_arr
       end
 

data/lib/plurimath/version.rb

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

data/lib/plurimath.rb

@@ -1,9 +1,8 @@
-
 require_relative "plurimath/version"
-require "lutaml/model"
 require "mml/configuration"
 
 def mml_adapter(adapter)
+  require "lutaml/model"
   Mml::Configuration.adapter = adapter unless Mml::Configuration.adapter
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox