plurimath 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43bfa34fd25956b0ee8308569e2f42f83f25a714e1d1f736d0b39f9fb464a312
-  data.tar.gz: df1e211c96baf094adb4d5fdb784b24d47750ac15c00ddfcd4ca9565f8d2e916
+  metadata.gz: def00e41e6010e06ea7df51573e342c4ed8b815e079bcbad3a7776cc5d625e02
+  data.tar.gz: d46595b7a57d2a391e849d58a6b23f7e449e042e891797967f13cee0364c32df
 SHA512:
-  metadata.gz: 6119f28efdfb00ad31b7fa32bab9d21b95c50c92a24be7610988677cb9708debcc9a8fd71d1896cea6595f9fe2ca1e7b5c1e33ca109aa9577b9bd1d246fc8cc3
-  data.tar.gz: 864c82b97e142080d9a5f2524e3879d0102721adb5788dbadfa1baaa3e7c89ea433c395e1b43d447556a72ae078b23b43d7dbb24d0032d9a19d2844bbfefc75b
+  metadata.gz: 5e5c0c02a41fcd2fdbebbd11ca103228ec5c9a2b4e68e98a364c39d988540ebfa844ad06785ced1538186ae7a0583978fe8c1a548c1da135d243d633557cc298
+  data.tar.gz: 15463a536fac275fe0935b360dd754ed787a202d4d77b4ef3f4934359e45ec4393e0c95bd6a7ce7f02a9e655f21eeeec312f932462354965a287e08e92b55e89

data/lib/plurimath/asciimath/transform.rb

@@ -896,6 +896,11 @@ module Plurimath
         Math::Formula.new([table] + expr.flatten.compact)
       end
 
+      rule(table: simple(:table),
+           left_right: simple(:left_right)) do
+        Math::Formula.new([table, left_right])
+      end
+
       rule(table: simple(:table),
            expr: simple(:expr)) do
         formula_array = [table]

data/lib/plurimath/formatter/number_formatter.rb

@@ -0,0 +1,114 @@
+require "twitter_cldr"
+require_relative "twitter_cldr_rb/integer"
+require_relative "twitter_cldr_rb/fraction"
+require_relative "twitter_cldr_rb/number_formatter"
+
+module Plurimath
+  module Formatter
+    class NumberFormatter
+      attr_accessor :locale, :localize_number, :localizer_symbols
+
+      LOCALIZE_NUMBER_REGEX = %r{(?<group>[^#])?(?<groupdigits>#+0)(?<decimal>.)(?<fractdigits>#+)(?<fractgroup>[^#])?}
+      SUPPORTED_NOTATIONS = %i[e scientific engineering].freeze
+
+      def initialize(locale, localize_number:, localizer_symbols:)
+        @locale = locale
+        @localize_number = localize_number
+        @localizer_symbols = localizer_symbols
+        @twitter_cldr_reader = twitter_cldr_reader(locale)
+      end
+
+      def localized_number(number_string, locale:, precision:, format:)
+        options_instance_variables(number_string, format, precision)
+        @twitter_cldr_reader.merge!(format)
+        return send("#{@notation}_format", number_string) if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+
+        localize_number(number_string)
+      end
+
+      private
+
+      def twitter_cldr_reader(locale)
+        num = TwitterCldr::DataReaders::NumberDataReader.new(locale)
+        num.symbols
+          .merge!(@localizer_symbols)
+          .merge!(parse_localize_number)
+      end
+
+      def parse_localize_number
+        @localize_number or return {}
+        m = LOCALIZE_NUMBER_REGEX.match(@localize_number) or return {}
+        ret = {
+          decimal: m[:decimal],
+          group_digits: m[:groupdigits].size,
+          fraction_group_digits: m[:fractdigits].size,
+          group: m[:group] == " " ? "\u00A0" : (m[:group] || ""),
+          fraction_group: m[:fractgroup] == " " ? "\u00A0" : (m[:fractgroup]  || "")
+        }.compact
+      end
+
+      def localize_number(num)
+        num = num.match?(/\./) ? num.to_f : num.to_i
+        localized = BigDecimal(num.to_s).localize(@locale)
+        return localized.to_s if @precision.zero?
+
+        localized.to_decimal.to_s(precision: @precision)
+      end
+
+      def e_format(num_str)
+        notations_formatting(num_str).join(@e.to_s)
+      end
+
+      def scientific_format(num_str)
+        notations_formatting(num_str).join(" #{@times} 10^")
+      end
+
+      def engineering_format(num_str)
+        @precision = num_str.length - 1 unless @precision > 0
+        chars = notation_chars(num_str)
+        update_string_index(chars, chars.last.to_i % 3)
+        chars[0] = localize_number(chars[0])
+        chars.join(" #{@times} 10^")
+      end
+
+      def update_exponent_sign(str)
+        str.gsub!("e", "e+") if @exponent_sign == :plus
+      end
+
+      def notation_chars(num_str)
+        notation_number = ("%.#{@precision}e" %num_str)
+        update_exponent_sign(notation_number.gsub!("+0", ""))
+        notation_number.split("e")
+      end
+
+      def notations_formatting(num_str)
+        chars = notation_chars(num_str)
+        chars[0] = localize_number(chars[0])
+        chars
+      end
+
+      def options_instance_variables(string, format, precision)
+        @e = format.delete(:e)&.to_sym || :e
+        @times = format.delete(:times)&.to_sym || "\u{d7}"
+        @notation = format.delete(:notation)&.to_sym || nil
+        @precision = update_precision(string, precision)
+        @exponent_sign = format.delete(:exponent_sign)&.to_sym || nil
+      end
+
+      def update_precision(num, precision)
+        return precision if precision
+        return num.sub(/\./, "").size - 1 if SUPPORTED_NOTATIONS.include?(@notation&.to_sym)
+
+        /\./.match?(num) ? num.sub(/^.*\./, "").size : 0
+      end
+
+      def update_string_index(chars, index)
+        return if index.zero?
+
+        chars.first.delete!(".")
+        chars.first.insert(index + 1, ".")
+        chars[-1] = (chars[-1].to_i - index).to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module TwitterCldr
+  module Formatters
+    module Numbers
+      class Fraction
+        attr_reader :format, :decimal, :precision, :separator, :group
+
+        def initialize(token, symbols = {})
+          @format  = token ? token.value.split('.').pop : ''
+          @decimal = symbols[:decimal] || '.'
+          @separator = symbols[:fraction_group] || " "
+          @group = symbols[:fraction_group_digits] || 3
+          @digit_count = symbols[:digit_count] || nil
+          @precision = @format.length
+        end
+
+        def apply(fraction, options = {}, int = "")
+          precision = options[:precision] || self.precision
+          return "" unless precision > 0
+
+          number = interpolate(format(options), fraction, :left)
+          number = digit_count_format(int, fraction, number) if @digit_count
+          decimal + change_format(precision, number)
+        end
+
+        def format(options)
+          precision = options[:precision] || self.precision
+          precision ? '0' * precision : @format
+        end
+
+        protected
+
+        def change_format(precision, string)
+          tokens = []
+          tokens << string&.slice!(0, group) until string&.empty?
+          tokens.compact.join(separator)
+        end
+
+        def digit_count_format(int, fraction, number)
+          integer = int + "." + fraction
+          float = integer.to_f
+          int_length = integer.length - 1
+          @digit_count ||= int_length
+          if int_length > @digit_count
+            float.round(@digit_count - int.length).to_s.split(".").last
+          elsif int_length < @digit_count
+            number += "0" * (@digit_count - int_length)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/plurimath/formatter/twitter_cldr_rb/integer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TwitterCldr
+  module Formatters
+    module Numbers
+      class Integer
+        def initialize(token, symbols = {})
+          format     = token.value.split('.')[0]
+          @format    = prepare_format(format, symbols)
+          @groups    = Array(symbols[:group_digits] || parse_groups(format))
+          @separator = symbols[:group] || ','
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/twitter_cldr_rb/number_formatter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TwitterCldr
+  module Formatters
+    class NumberFormatter
+      def format(tokens, number, options = {})
+        options[:precision] ||= precision_from(number)
+        options[:type] ||= :decimal
+
+        prefix, suffix, integer_format, fraction_format = *partition_tokens(tokens)
+        number = truncate_number(number, integer_format.format.length)
+
+        int, fraction = parse_number(number, options)
+        result = integer_format.apply(int, options)
+        result << fraction_format.apply(fraction, options, int) if fraction
+
+        number_system.transliterate(
+          "#{prefix.to_s}#{result}#{suffix.to_s}"
+        )
+      end
+    end
+  end
+end

data/lib/plurimath/math/formula.rb

@@ -288,26 +288,19 @@ module Plurimath
 
       def unitsml_post_processing(nodes)
         nodes.each.with_index do |node, index|
-          if node.is_a?(Ox::Element) && node.attributes&.dig(:unitsml)
-            previous = nodes[index-1]
-            if previous && ["mi", "mn"].include?(previous.name)
-              if text_in_tag?(node.nodes)
-                nodes.insert(index, space_element(attributes: true))
-              else
-                nodes.insert(index, space_element)
-              end
-            end
-
-            node.attributes.delete_if {|k, v| k == :unitsml }
+          if node.is_a?(Ox::Element) && node&.attributes&.dig(:unitsml)
+            pre_index = index - 1
+            pre_node = nodes[pre_index] if pre_index.zero? || pre_index.positive?
+            nodes.insert(index, space_element(node)) if valid_previous?(pre_node)
+            node.attributes.delete_if { |k, _| k == :unitsml }
           end
-
-          unitsml_post_processing(node.nodes) if !node.nodes.any?(String)
+          unitsml_post_processing(node.nodes) if node.nodes.none?(String)
         end
       end
 
-      def space_element(attributes: false)
+      def space_element(node)
         element = (ox_element("mo") << "&#x2062;")
-        element.attributes[:rspace] = "thickmathspace" if attributes
+        element.attributes[:rspace] = "thickmathspace" if text_in_tag?(node.nodes)
         element
       end
 
@@ -327,6 +320,17 @@ module Plurimath
       def unicodemath_value
         (negated_value? || mini_sized?) ? value&.map(&:to_unicodemath)&.join : value&.map(&:to_unicodemath)&.join(" ")
       end
+
+      def valid_previous?(previous)
+        return unless previous
+
+        ["mi", "mn"].include?(previous.name) ||
+          inside_tag?(previous)
+      end
+
+      def inside_tag?(previous)
+        previous&.nodes&.any? { |node| valid_previous?(node) if node.is_a?(Ox::Element) }
+      end
     end
   end
 end

data/lib/plurimath/math.rb

@@ -7,6 +7,7 @@ require_relative "mathml"
 require_relative "html"
 require_relative "latex"
 require_relative "unitsml"
+require_relative "number_formatter"
 require_relative "math/core"
 require_relative "math/number"
 require_relative "math/symbol"

data/lib/plurimath/mathml/transform.rb

@@ -191,8 +191,12 @@ module Plurimath
         elsif flatten_mrow&.first&.is_nary_function? && flatten_mrow.length == 2
           nary_function = flatten_mrow.first
           if nary_function.is_ternary_function? && nary_function.all_values_exist?
-            flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
-            flatten_mrow
+            if nary_function.respond_to?(:new_nary_function)
+              flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
+              flatten_mrow
+            else
+              Utility.filter_values(flatten_mrow)
+            end
           elsif nary_function.is_binary_function? && nary_function.any_value_exist?
             flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
             flatten_mrow

data/lib/plurimath/number_formatter.rb

@@ -0,0 +1,32 @@
+require "plurimath/formatter/number_formatter"
+
+module Plurimath
+  class NumberFormatter
+    attr_accessor :locale, :localize_number, :localizer_symbols
+
+    def initialize(locale = "en", localize_number: nil, localizer_symbols: {})
+      @locale = supported_locale(locale)
+      @localize_number = localize_number
+      @localizer_symbols = localizer_symbols
+    end
+
+    def localized_number(number_string, locale: @locale, precision: nil, format: {})
+      Formatter::NumberFormatter.new(
+        supported_locale(locale),
+        localize_number: localize_number,
+        localizer_symbols: localizer_symbols,
+      ).localized_number(
+        number_string,
+        locale: supported_locale(locale),
+        precision: precision,
+        format: format,
+      )
+    end
+
+    private
+
+    def supported_locale(locale)
+      TwitterCldr.supported_locale?(locale.to_sym) ? locale.to_sym : :en
+    end
+  end
+end

data/lib/plurimath/version.rb

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

data/plurimath.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.add_dependency 'twitter_cldr'
   spec.add_dependency 'parslet'
   spec.add_dependency 'ox'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-11 00:00:00.000000000 Z
+date: 2024-05-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: twitter_cldr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +84,10 @@ files:
 - lib/plurimath/asciimath/parse.rb
 - lib/plurimath/asciimath/parser.rb
 - lib/plurimath/asciimath/transform.rb
+- lib/plurimath/formatter/number_formatter.rb
+- lib/plurimath/formatter/twitter_cldr_rb/fraction.rb
+- lib/plurimath/formatter/twitter_cldr_rb/integer.rb
+- lib/plurimath/formatter/twitter_cldr_rb/number_formatter.rb
 - lib/plurimath/html.rb
 - lib/plurimath/html/constants.rb
 - lib/plurimath/html/parse.rb
@@ -214,6 +232,7 @@ files:
 - lib/plurimath/mathml/constants.rb
 - lib/plurimath/mathml/parser.rb
 - lib/plurimath/mathml/transform.rb
+- lib/plurimath/number_formatter.rb
 - lib/plurimath/omml.rb
 - lib/plurimath/omml/parser.rb
 - lib/plurimath/omml/transform.rb
@@ -259,7 +278,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Converts LaTeX math into MathML.