plurimath 0.8.10 → 0.8.12

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/parser.rb

@@ -8,17 +8,10 @@ module Plurimath
     class Parser
       attr_accessor :text
 
+      TEXT_REGEX = %r(\\(?:mbox|text){[^}]+})
+
       def initialize(text)
-        enti = HTMLEntities.new
-        text = enti.encode(enti.decode(text), :hexadecimal)
-        text = text
-          .gsub(/((?<!\\) )|\n+/, "")
-          .gsub(/\\\\ /, "\\\\\\\\")
-          .gsub(/&#x26;/, "&")
-          .gsub(/&#x22;/, "\"")
-          .gsub(/(?<!\\\\)\\&#xa;/, "\\ ")
-          .gsub(/&#xa;/, "")
-        @text = text
+        @text = pre_processing(text)
       end
 
       def parse
@@ -28,6 +21,26 @@ module Plurimath
 
         Math::Formula.new(formula)
       end
+
+      private
+
+      def pre_processing(text)
+        text_functions = text.scan(TEXT_REGEX)
+        enti = HTMLEntities.new
+        text = enti.encode(enti.decode(text), :hexadecimal)
+        text = gsub_space_and_unicodes(text)
+        text.gsub(TEXT_REGEX) { |str| text_functions.shift }
+      end
+
+      def gsub_space_and_unicodes(text)
+        text
+          .gsub(/((?<!\\) )|\n+/, "")
+          .gsub(/\\\\ /, "\\\\\\\\")
+          .gsub(/&#x26;/, "&")
+          .gsub(/&#x22;/, "\"")
+          .gsub(/(?<!\\\\)\\&#xa;/, "\\ ")
+          .gsub(/&#xa;/, "")
+      end
     end
   end
 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,18 @@ 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 unicodemath_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_unicodemath}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field, lang: :unicodemath)
+
+        options[:array] << field&.to_unicodemath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      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 +140,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 +220,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 +285,8 @@ module Plurimath
 
       def is_nary_symbol?;end
 
+      def nary_intent_name;end
+
       def is_binary_function?
         is_a?(Function::BinaryFunction)
       end
@@ -306,36 +314,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