plurimath 0.8.10 → 0.8.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896215930a897878dac674f1be1092b3c6e8f330e20ffe218421b01e0aa98cbc
-  data.tar.gz: ad8d176647c84540c11f8ed736e5e816ec88cf65d029b605cf280e326ea7c91a
+  metadata.gz: 2125384d29ad98d919d7fd71cebaf3e5fdc6ffc1aa8df386f3b63f20754ae6bb
+  data.tar.gz: 64a002bc99ed60eada7e7a59df1f0bfa083eaa4427efdb0ec2fbe615db33f851
 SHA512:
-  metadata.gz: 2414d5501af2bd824d56e0557132ec650eb3bddfa44180e6d2561ae11f976d2c0edffc90bc00d9d442e41b31d5c2c900c9f5e16fad770b2717810ea79f2470aa
-  data.tar.gz: 124779151cac821ea29ed9d3cd12f61bd41efb1273e9912cb92377e7ee4d4854ca91906838c8cedd540f76fc8a5c9b17256651bd933bffe582ee026cc6609c8b
+  metadata.gz: a88aae5ca0beb6e36de8f3e025241cb291cb2d8c44faeeb2325ea4a2276ca6c93b32176484d7698a6818cf5f05e76f3a8b0fad829ed657f417a7fda183726ba9
+  data.tar.gz: fb521143940cab36ef15320d65aad971e56e150776229809fa9bdd1014847ac36cfef09fc55f2e182338ee2e1e2a6d13f086eb0a285d01e51b847df1c07cbe53

data/lib/plurimath/formatter/number_formatter.rb

@@ -7,13 +7,15 @@ module Plurimath
         options[:precision] ||= precision_from(number)
         options[:type] ||= :decimal
 
-        prefix, suffix, integer_format, fraction_format = *partition_tokens(tokens)
+        prefix, suffix, integer_format, fraction_format, signif_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
 
+        result = signif_format.apply(result, integer_format, fraction_format)
+
         number_system.transliterate(
           "#{prefix.to_s}#{result}#{suffix.to_s}"
         )
@@ -32,6 +34,9 @@ module Plurimath
           Numbers::Fraction.new(
             tokens[1],
             data_reader.symbols
+          ),
+          Numbers::Significant.new(
+            data_reader.symbols,
           )
         ]
       end

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

@@ -21,7 +21,7 @@ module Plurimath
 
           number = interpolate(format(options), fraction, :left)
           number = digit_count_format(int, fraction, number) if @digit_count
-          formatted_number = change_format(precision, number) if number
+          formatted_number = change_format(number) if number
           formatted_number ? decimal + formatted_number : ""
         end
 
@@ -30,9 +30,13 @@ module Plurimath
           precision ? '0' * precision : @format
         end
 
+        def format_groups(string)
+          change_format(string)
+        end
+
         protected
 
-        def change_format(precision, string)
+        def change_format(string)
           tokens = []
           tokens << string&.slice!(0, (group || string.length)) until string&.empty?
           tokens.compact.join(separator)
@@ -45,13 +49,33 @@ module Plurimath
           @digit_count ||= int_length
           if int_length > @digit_count
             number_string = float.round(@digit_count - int.length)
-            @digit_count > int.length ? number_string.to_s("F").split(".").last : nil
+            numeric_digits(number_string) if @digit_count > int.length
           elsif int_length < @digit_count
-            number + "0" * (@digit_count - int_length)
+            number + "0" * (update_digit_count(number) - int_length)
           else
             number
           end
         end
+
+        def numeric_digits(num_str)
+          float = num_str.to_s("F")
+          return float.split(".").last if float.length == @digit_count + 1
+          return unless @digit_count + 1 > float.length
+
+          float.split(".")[0] + ("0" * (@digit_count - float.length + 1))
+        end
+
+        def update_digit_count(number)
+          return @digit_count unless all_zeros?(number) == @precision
+
+          @digit_count - @precision + 1
+        end
+
+        def all_zeros?(number)
+          return unless number.split('').all? { |dig| dig == "0" }
+
+          number.length
+        end
       end
     end
   end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Formatter
+    module Numbers
+      class Significant
+        attr_accessor :symbols, :decimal, :significant
+
+        def initialize(symbols)
+          @symbols = symbols
+          @decimal = symbols[:decimal]
+          @significant = symbols[:significant].to_i
+        end
+
+        def apply(string, int_format, frac_format)
+          return string if significant.zero?
+          return string unless string.match?(/[1-9]/)
+          chars = string.split("")
+
+          return string if count_chars(chars, true) == significant
+
+          string = signify(chars)
+          integer, fraction = string.split(decimal)
+          string = [format_groups(int_format, integer)]
+          string << format_groups(frac_format, fraction) if fraction
+          string.join(decimal)
+        end
+
+        protected
+
+        def signify(chars)
+          sig_num   = false
+          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]/)
+            break if sig_count.zero?
+
+            new_chars << char
+            next unless sig_num
+            next unless char.match?(/[0-9]/)
+
+            sig_count -= 1
+          end
+
+          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
+              round_str(chars, new_chars, frac_part)
+              remain_chars = 0 if frac_part && remain_chars == 1
+            end
+            new_chars << ("0" * remain_chars) unless frac_part && sig_char_count(new_chars)
+          end
+          new_chars.join
+        end
+
+        def round_str(chars, array, frac_part)
+          arr_len = array.length
+          char_ind = chars[arr_len]&.match?(/[0-9]/) ? arr_len : arr_len + 1
+          return unless chars[char_ind]&.match?(/[5-9]/)
+
+          frac_part = false if chars[arr_len] == decimal
+          prev_ten  = false
+          array.reverse!.each.with_index do |char, ind|
+            if char == decimal
+              array[ind] = ""
+              frac_part  = false
+              next
+            end
+            next unless char.match?(/[0-9]/)
+
+            if char == "9"
+              prev_ten   = true
+              array[ind] = frac_part ? "" : "0"
+              next
+            end
+            char.next!
+            prev_ten = false
+            break
+          end
+          array << "1" if prev_ten
+          array.reverse!
+        end
+
+        def count_chars(chars, fraction)
+          counting = 0
+          chars.each do |char|
+            break if char == decimal && !fraction
+
+            counting += 1 if char.match?(/\d/)
+          end
+          counting
+        end
+
+        def change_format(string, separator, group)
+          tokens = []
+          tokens << string&.slice!(0, group) until string&.empty?
+          tokens.compact.join(separator)
+        end
+
+        def format_groups(format, string)
+          format.format_groups(numeric_string(string, format))
+        end
+
+        def numeric_string(string, format)
+          string.split(format.separator).join
+        end
+
+        def sig_char_count(chars)
+          start_counting = false
+          counting = 0
+          chars.each do |char|
+            start_counting = true if char.match(/[1-9]/)
+            next unless start_counting
+
+            counting += 1 if char.match?(/\d/)
+          end
+          counting == significant
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -1,6 +1,7 @@
 require "twitter_cldr"
 require_relative "numbers/integer"
 require_relative "numbers/fraction"
+require_relative "numbers/significant"
 require_relative "number_formatter"
 require_relative "number_data_reader"
 require_relative "localized_number"
@@ -66,6 +67,7 @@ module Plurimath
 
       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])
@@ -76,24 +78,34 @@ module Plurimath
         str.gsub!("e", "e+") if @exponent_sign == :plus
       end
 
+      def update_exponent_value(number_str)
+        exponent_number = BigDecimal(number_str) - 1
+        "#{"+" if @exponent_sign == :plus}#{exponent_number.to_i}"
+      end
+
       def notation_chars(num_str)
-        notation_number = ("%.#{@precision}e" %num_str)
-        update_exponent_sign(notation_number.gsub!("+0", ""))
-        notation_number.split("e")
+        notation_array = BigDecimal(num_str).to_s("e").split("e")
+        notation_array[1] = update_exponent_value(notation_array[1])
+        number_str = notation_array[0]
+        number_str.gsub!(/0\.(\d)/, '\1.')
+        number_str.sub!('.', '') if number_str.start_with?(".")
+        notation_array[0] = number_str[0..-2] if number_str.end_with?(".")
+        notation_array
       end
 
       def notations_formatting(num_str)
         chars = notation_chars(num_str)
         chars[0] = localize_number(chars[0])
+        chars << "0" if chars.length == 1
         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
+        @e = format[:e]&.to_sym || :e
+        @times = format[:times]&.to_sym || "\u{d7}"
+        @notation = format[:notation]&.to_sym || nil
         @precision = update_precision(string, precision)
-        @exponent_sign = format.delete(:exponent_sign)&.to_sym || nil
+        @exponent_sign = format[:exponent_sign]&.to_sym || nil
       end
 
       def update_precision(num, precision)
@@ -107,7 +119,7 @@ module Plurimath
         return if index.zero?
 
         chars.first.delete!(".")
-        chars.first.insert(index + 1, ".")
+        chars.first.insert(index + 1, ".") unless chars.first[index + 2].nil?
         chars[-1] = (chars[-1].to_i - index).to_s
       end
 

data/lib/plurimath/latex/transform.rb

@@ -283,12 +283,30 @@ module Plurimath
 
       rule(sequence: simple(:sequence),
            expression: simple(:expr)) do
-        [sequence, expr].compact
+        if sequence.is_a?(Math::Function::PowerBase) && sequence.parameter_one.is_nary_symbol?
+          Math::Function::Nary.new(
+            sequence.parameter_one,
+            sequence.parameter_two,
+            sequence.parameter_three,
+            expr,
+          )
+        else
+          [sequence, expr].compact
+        end
       end
 
       rule(sequence: simple(:sequence),
            expression: sequence(:expr)) do
-        [sequence] + expr
+        if sequence.is_a?(Math::Function::PowerBase) && sequence.parameter_one.is_nary_symbol?
+          Math::Function::Nary.new(
+            sequence.parameter_one,
+            sequence.parameter_two,
+            sequence.parameter_three,
+            Utility.filter_values(expr),
+          )
+        else
+          [sequence] + expr
+        end
       end
 
       rule(unary_functions: simple(:unary),

data/lib/plurimath/math/core.rb

@@ -6,7 +6,7 @@ module Plurimath
       REPLACABLES = {
         /&/ => "&",
         /^\n/ => "",
-      }
+      }.freeze
 
       def class_name
         self.class.name.split("::").last.downcase
@@ -100,7 +100,7 @@ module Plurimath
 
         hashed = common_math_zone_conversion(field, options)
         options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field)}\"#{hashed[:field_name]}\n"
-        return unless Utility.validate_math_zone(field, lang: :mathml)
+        return unless Utility.validate_math_zone(field, lang: :mathml, intent: options[:intent])
 
         options[:array] << field&.to_mathml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
       end
@@ -116,8 +116,8 @@ module Plurimath
         options[:array] << field&.to_omml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], display_style: display_style)
       end
 
-      def dump_mathml(field)
-        dump_ox_nodes(field.to_mathml_without_math_tag).gsub(/\n\s*/, "")
+      def dump_mathml(field, intent = false)
+        dump_ox_nodes(field.to_mathml_without_math_tag(intent)).gsub(/\n\s*/, "")
       end
 
       def dump_omml(field, display_style)
@@ -130,11 +130,11 @@ module Plurimath
         to_omml_without_math_tag(display_style)
       end
 
-      def validate_mathml_fields(field)
+      def validate_mathml_fields(field, intent)
         if field.is_a?(Array)
-          field&.map(&:to_mathml_without_math_tag)
+          field&.map { |object| object.to_mathml_without_math_tag(intent) }
         else
-          field&.to_mathml_without_math_tag
+          field&.to_mathml_without_math_tag(intent)
         end
       end
 
@@ -210,11 +210,7 @@ module Plurimath
             field.line_breaking(obj)
             updated_object_values(variable, obj: obj, update_value: true) if obj.value_exist?
           when Array
-            if result(field).length > 1
-              updated_object_values(variable, obj: obj)
-            else
-              field.each { |object| object.line_breaking(obj) }
-            end
+            array_line_break_field(field, variable, obj)
           end
         end
       end
@@ -279,6 +275,8 @@ module Plurimath
 
       def is_nary_symbol?;end
 
+      def nary_intent_name;end
+
       def is_binary_function?
         is_a?(Function::BinaryFunction)
       end
@@ -306,36 +304,120 @@ module Plurimath
 
       private
 
-      def prime_classes
-        %w[
-          backtrprime
-          backtrprime
-          backdprime
-          backdprime
-          backprime
-          backprime
-          pppprime
-          pppprime
-          pppprime
-          pppprime
-          ppprime
-          ppprime
-          ppprime
-          ppprime
-          dprime
-          dprime
-          dprime
-          pprime
-          dprime
-          prime
-          prime
-          prime
-        ].freeze
+      def array_line_break_field(field, variable, obj)
+        if result(field).length > 1
+          updated_object_values(variable, obj: obj)
+        else
+          field.each { |object| object.line_breaking(obj) }
+        end
       end
 
       def unicodemath_field_value(field)
         field.class_name == "symbol" ? field.value : Utility.hexcode_in_input(field)
       end
+
+      def wrap_mrow(xml_engine_node, intent)
+        return xml_engine_node if xml_engine_node.name == "mrow"
+        return xml_engine_node unless intent
+
+        ox_element("mrow") << xml_engine_node
+      end
+
+      def intentify(tag, intent, func_name:, intent_name: nil)
+        return tag unless intent
+
+        Utility::IntentEncoding.send("#{func_name}_intent", tag, intent_name)
+      end
+
+      def masked_tag(tag)
+        options_array = get_mask_options
+        if options_array.include?("show_up_limit_place_holder") && parameter_three.nil?
+          set_place_holder(tag, type: :above)
+        end
+        if options_array.include?("show_low_limit_place_holder") && parameter_two.nil?
+          set_place_holder(tag, type: :below)
+        end
+        if options_array.include?("limits_opposite")
+          change_power_base_values(tag)
+        end
+        if options_array.include?("limits_under_over")
+          case tag.name
+          when "msubsup" then tag.name = "munderover"
+          when "msub" then tag.name = "munder"
+          when "msup" then tag.name = "mover"
+          end
+        elsif options_array.include?("limits_sub_sup")
+          case tag.name
+          when "munderover" then tag.name = "msubsup"
+          when "munder" then tag.name = "msub"
+          when "mover" then tag.name = "msup"
+          end
+        elsif options_array.include?("upper_limit_as_super_script") && tag.nodes[1].name == "mrow"
+          tag = Utility.update_nodes(
+            ox_element("munder"),
+            [
+              Utility.update_nodes(
+                ox_element("msup"),
+                [
+                  tag.nodes[0],
+                  tag.nodes[2],
+                ],
+              ),
+              tag.nodes[1],
+            ],
+          )
+        end
+        tag
+      end
+
+      def get_mask_options(mask_options = [])
+        mask = options&.dig(:mask).to_i
+
+        case mask % 4
+        when 0 then mask_options << "limits_default"
+        when 1 then mask_options << "limits_under_over"
+        when 2 then mask_options << "limits_sub_sup"
+        when 3 then mask_options << "upper_limit_as_super_script"
+        end
+
+        mask -= mask % 4
+
+        case mask % 32
+        when 4 then mask_options << "limits_opposite"
+        when 8 then mask_options << "show_low_limit_place_holder"
+        when 12 then mask_options += ["limits_opposite", "show_low_limit_place_holder"]
+        when 16 then mask_options << "show_up_limit_place_holder"
+        when 20 then mask_options += ["limits_opposite", "show_up_limit_place_holder"]
+        when 24 then mask_options += ["show_low_limit_place_holder", "show_up_limit_place_holder"]
+        when 28 then mask_options += ["limits_opposite", "show_low_limit_place_holder", "show_up_limit_place_holder"]
+        end
+
+        mask_options
+      end
+
+      def change_power_base_values(tag)
+        return unless ["munderover", "msubsup"].include?(tag.name)
+
+        Plurimath.xml_engine.replace_nodes(
+          tag,
+          [tag.nodes[0], tag.nodes[2], tag.nodes[1]],
+        )
+      end
+
+      def set_place_holder(node, type:)
+        nodes = if type == :below
+                  node.name = node.name == "msup" ? "msubsup" : "munderover"
+                  node.nodes.insert(1, mo_tag("&#x2b1a;"))
+                else
+                  node.name = node.name == "msub" ? "msubsup" : "munderover"
+                  node.nodes.insert(2, mo_tag("&#x2b1a;"))
+                end
+        Plurimath.xml_engine.replace_nodes(node, nodes)
+      end
+
+      def mo_tag(str)
+        ox_element("mo") << str
+      end
     end
   end
 end