plurimath 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27853f7e998552c58b54113306cf188d8c8e64bad83cf31a688abc7414dd6d9
-  data.tar.gz: ccd6b77d70a82d3e2727a65d6f3976e4afc1b3454753ddb7d6a6837206735b7c
+  metadata.gz: e695891a5d39be6da60ecc15c99e10084cd0e547eb01f19101fc04e86aad3af9
+  data.tar.gz: ec8a0ac035d3623d64e2a28bd2c6b51666586c1543e86735e497bfd93de6616d
 SHA512:
-  metadata.gz: a8a69ff2bb1379646f798502cfb307adb9df9be44c129da7d1d2bf2ee1cca61086a0d1124e5d22d0460ab166da44ac9a82bf41ba770a097eef4d78f35127635d
-  data.tar.gz: 48aa6427c4a764e3736a0ca8b7af503bcc1d8000fb2807f5fe42ba902f1cd73221e74384da0ac0f14b482c3792c7941eb59d70699790cc100cad4b6ba5fab60a
+  metadata.gz: 86c19de5ceaf9218d6d48aaf1f8845412d90012497776cf4535c62d23660e8d3af7b4ad2f2cb67147251d246ddad596f90305f2347088c10cc6effa5de5e09a6
+  data.tar.gz: 52d275e8b523063b33413bc604e5dea41ad2f14ac7f06cd65638ccf8c0f44c8556f06af1236ea151abdc961dda2685adf907c6a6df46f2a3ae0a8a4bc5a645d3

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "submodules/unicodemath-tests"]
+	path = submodules/unicodemath-tests
+	url = git@github.com:plurimath/unicodemath-tests.git

data/Latex-Supported-Data.adoc

@@ -944,6 +944,7 @@
 * `supseteqq`
 * `leqqslant`
 * `geqqslant`
+* `emptyset`
 * `horizbar`
 * `Question`
 * `medspace`

data/lib/plurimath/asciimath/parse.rb

@@ -69,7 +69,7 @@ module Plurimath
       end
 
       rule(:quoted_text) do
-        (str('"') >> str("unitsml(") >> match("[^\)\"]").repeat.as(:unitsml) >> str(')"')) |
+        (str('"') >> str("unitsml(") >> (str(')"').absent? >> any).repeat.as(:unitsml) >> str(')"')) |
           (str('"') >> match("[^\"]").repeat.as(:text) >> str('"')) |
           (str('"') >> str("").as(:text))
       end

data/lib/plurimath/asciimath/transform.rb

@@ -29,9 +29,7 @@ module Plurimath
       rule(mod: simple(:mod), expr: simple(:expr)) { [mod, expr] }
 
       rule(unitsml: simple(:unitsml)) do
-        Utility.filter_values(
-          Unitsml.new(unitsml.to_s).to_formula.value,
-        )
+        Unitsml.new(unitsml.to_s).to_formula
       end
 
       rule(bold_fonts: simple(:font)) do
@@ -881,9 +879,7 @@ module Plurimath
       rule(unary_class: simple(:function),
            unitsml: simple(:unitsml)) do
         Utility.get_class(function).new(
-          Utility.filter_values(
-            Unitsml.new(unitsml.to_s).to_formula.value,
-          ),
+          Unitsml.new(unitsml.to_s).to_formula,
         )
       end
 

data/lib/plurimath/latex/constants.rb

@@ -883,6 +883,7 @@ module Plurimath
         supseteqq: "⫆",
         leqqslant: "⫹",
         geqqslant: "⫺",
+        emptyset: "∅",
         horizbar: "―",
         Question: "⁇",
         medspace: " ",
@@ -2705,6 +2706,7 @@ module Plurimath
         leqqslant: :symbols,
         geqqslant: :symbols,
         mbfitsans: :fonts,
+        emptyset: :symbols,
         horizbar: :symbols,
         Question: :symbols,
         medspace: :symbols,

data/lib/plurimath/math/core.rb

@@ -28,9 +28,11 @@ module Plurimath
         ""
       end
 
-      def empty_tag(wrapper_tag)
+      def empty_tag(wrapper_tag = nil)
         r_tag = ox_element("r", namespace: "m")
         r_tag << (ox_element("t", namespace: "m") << "&#8203;")
+        return r_tag unless wrapper_tag
+
         wrapper_tag << r_tag
       end
 
@@ -38,10 +40,12 @@ module Plurimath
         tag = ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
-        Utility.update_nodes(
-          tag,
-          field.insert_t_tag(display_style),
-        )
+        field_value = if field.is_a?(Array)
+                        field.map { |object| object.insert_t_tag(display_style) }
+                      else
+                        field.insert_t_tag(display_style)
+                      end
+        Utility.update_nodes(tag, field_value)
       end
 
       def validate_function_formula
@@ -127,7 +131,11 @@ module Plurimath
       end
 
       def validate_mathml_fields(field)
-        field.nil? ? ox_element("mi") : field.to_mathml_without_math_tag
+        if field.is_a?(Array)
+          field&.map(&:to_mathml_without_math_tag)
+        else
+          field&.to_mathml_without_math_tag
+        end
       end
 
       def common_math_zone_conversion(field, options = {})
@@ -266,6 +274,30 @@ module Plurimath
       def is_unary?
         is_a?(Math::Function::UnaryFunction)
       end
+
+      def is_nary_function?;end
+
+      def is_nary_symbol?;end
+
+      def is_binary_function?
+        is_a?(Function::BinaryFunction)
+      end
+
+      def is_ternary_function?
+        is_a?(Function::TernaryFunction)
+      end
+
+      def mini_sized?
+        false
+      end
+
+      def unicodemath_parens(field)
+        if field.is_a?(Math::Function::Fenced)
+          field.to_unicodemath
+        else
+          "(#{field.to_unicodemath})" if field
+        end
+      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -3,7 +3,7 @@
 module Plurimath
   module Math
     class Formula < Core
-      attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string
+      attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string, :unitsml
 
       MATH_ZONE_TYPES = %i[
         omml
@@ -16,12 +16,14 @@ module Plurimath
         value = [],
         left_right_wrapper = true,
         display_style: true,
-        input_string: nil
+        input_string: nil,
+        unitsml: false
       )
         @value = value.is_a?(Array) ? value : [value]
         left_right_wrapper = false if @value.first.is_a?(Function::Left)
         @left_right_wrapper = left_right_wrapper
         @displaystyle = boolean_display_style(display_style)
+        @unitsml = unitsml if unitsml
       end
 
       def ==(object)
@@ -49,6 +51,7 @@ module Plurimath
         style = ox_element("mstyle", attributes: style_attrs)
         Utility.update_nodes(style, mathml_content)
         Utility.update_nodes(math, [style])
+        unitsml_post_processing(math)
         dump_nodes(math, indent: 2)
       rescue
         parse_error!(:mathml)
@@ -63,10 +66,9 @@ module Plurimath
       def to_mathml_without_math_tag
         return mathml_content unless left_right_wrapper
 
-        Utility.update_nodes(
-          Utility.ox_element("mrow"),
-          mathml_content,
-        )
+        mrow = ox_element("mrow")
+        mrow.attributes[:unitsml] = true if unitsml
+        Utility.update_nodes(mrow, mathml_content)
       end
 
       def mathml_content
@@ -134,6 +136,12 @@ module Plurimath
         omml_content(display_style)
       end
 
+      def to_unicodemath
+        Utility.html_entity_to_unicode(unicodemath_value).gsub(/\s\/\s/, "/")
+      rescue
+        parse_error!(:unicodemath)
+      end
+
       def to_display(type = nil)
         return type_error! unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
 
@@ -247,6 +255,10 @@ module Plurimath
       end
 
 
+      def mini_sized?
+        true if value&.first&.mini_sized?
+      end
+
       protected
 
       def boolean_display_style(display_style = displaystyle)
@@ -273,6 +285,48 @@ module Plurimath
         r_tag = ox_element("r", namespace: "m")
         r_tag << ox_element("br")
       end
+
+      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 }
+          end
+
+          unitsml_post_processing(node.nodes) if !node.nodes.any?(String)
+        end
+      end
+
+      def space_element(attributes: false)
+        element = (ox_element("mo") << "&#x2062;")
+        element.attributes[:rspace] = "thickmathspace" if attributes
+        element
+      end
+
+      def text_in_tag?(nodes)
+        next_nodes = nodes.first.nodes
+        if next_nodes.all?(String)
+          Utility.html_entity_to_unicode(next_nodes.first).match?(/\p{L}|\p{N}/)
+        else
+          text_in_tag?(next_nodes)
+        end
+      end
+
+      def negated_value?
+        value.last.is_a?(Math::Symbol) && value.last.value == "&#x338;"
+      end
+
+      def unicodemath_value
+        (negated_value? || mini_sized?) ? value&.map(&:to_unicodemath)&.join : value&.map(&:to_unicodemath)&.join(" ")
+      end
     end
   end
 end

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

@@ -34,6 +34,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "⒜#{unicodemath_parens(parameter_one)}"
+        end
+
         protected
 
         def md_tag

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Arg < BinaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one.to_mathml_without_math_tag
+          first_value.attributes[:arg] = Utility.html_entity_to_unicode(parameter_two.value)
+          first_value
+        end
+
+        def to_unicodemath
+          first_value = "(#{parameter_two&.to_unicodemath} #{parameter_one&.to_unicodemath})" if parameter_one || parameter_two
+          "ⓐ#{first_value}"
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,10 @@ module Plurimath
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̅"
+        end
+
         protected
 
         def acc_tag(display_style)

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Base < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "subscript",
           first_value: "base",
           second_value: "script",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value = parameter_one.to_asciimath if parameter_one
           second_value = "_#{wrapped(parameter_two)}" if parameter_two
@@ -55,6 +68,20 @@ module Plurimath
           [ssub_element]
         end
 
+        def to_unicodemath
+          first_value = parameter_one.to_unicodemath if parameter_one
+          second_value = if parameter_two.is_a?(self.class)
+            "_#{size_overrides}#{parameter_two.to_unicodemath}"
+          elsif parameter_two&.mini_sized?
+            parameter_two.to_unicodemath
+          elsif parameter_two.nil?
+            "()"
+          else
+            "_#{size_overrides}#{unicodemath_parens(parameter_two)}"
+          end
+          "#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -68,6 +95,28 @@ module Plurimath
             obj.update(self.class.new(nil, Utility.filter_values(obj.value)))
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, parameter_two, nil, fourth_value)
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        end
+
+        protected
+
+        def size_overrides
+          return if options.nil? || options&.empty?
+
+          "Ⅎ#{UnicodeMath::Constants::SIZE_OVERRIDES_SYMBOLS.invert[options[:size]]}" if options[:size]
+        end
+
+        def unicodemath_parens(field)
+          return "〖#{field.to_unicodemath}〗" unless options.nil? || options&.empty?
+
+          super(field)
+        end
       end
     end
   end

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

@@ -131,6 +131,12 @@ module Plurimath
           underset = Underset.new(overset, parameter_one)
           Array(underset.to_omml_without_math_tag(display_style))
         end
+
+        def prime_unicode?(field)
+          return unless field.is_a?(Math::Symbol)
+
+          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) || field.value.include?("'") }
+        end
       end
     end
   end

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

@@ -18,6 +18,11 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           omml_value(display_style)
         end
+
+        def to_unicodemath
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          "╱#{first_value}"
+        end
       end
     end
   end

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

@@ -31,6 +31,12 @@ module Plurimath
           "<i>&#x2308;</i>#{first_value}<i>&#x2309;</i>"
         end
 
+        def to_unicodemath
+          first_value = "&#x2308;" unless open_paren
+          second_value = "&#x2309;" unless close_paren
+          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -6,12 +6,20 @@ module Plurimath
   module Math
     module Function
       class Color < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "color",
           first_value: "mathcolor",
           second_value: "text",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath&.gsub(/\s/, '')})"
           second_value = "(#{parameter_two&.to_asciimath})"
@@ -19,10 +27,11 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
+          color_value = parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "")
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
-              attributes: { mathcolor: parameter_one&.to_asciimath&.gsub(/\s/, "")&.gsub(/"/, "") },
+              attributes: { attr_key => color_value },
             ),
             [parameter_two&.to_mathml_without_math_tag],
           )
@@ -45,6 +54,16 @@ module Plurimath
           omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: "text", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
           new_arr
         end
+
+        def to_unicodemath
+          "✎(#{parameter_one.to_unicodemath}&#{parameter_two.to_unicodemath})"
+        end
+
+        protected
+
+        def attr_key
+          (options && options[:backcolor]) ? :mathbackground : :mathcolor
+        end
       end
     end
   end

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

@@ -33,6 +33,10 @@ module Plurimath
           "#{first_value}<i>..</i>"
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̈"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

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

@@ -41,6 +41,11 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          "#{first_value}̇"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

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

@@ -6,6 +6,22 @@ module Plurimath
   module Math
     module Function
       class Fenced < TernaryFunction
+        attr_accessor :options
+
+        def initialize(
+              parameter_one = nil,
+              parameter_two = nil,
+              parameter_three = nil,
+              options = {})
+          super(parameter_one, parameter_two, parameter_three)
+          @options = options
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value  = parameter_one ? parameter_one.to_asciimath : "("
           third_value  = parameter_three ? parameter_three.to_asciimath : ")"
@@ -13,9 +29,9 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value = Utility.ox_element("mo") << (mathml_paren(parameter_one) || "")
+          first_value = Utility.ox_element("mo", attributes: options&.dig(:open_paren)) << (mathml_paren(parameter_one) || "")
           second_value = parameter_two&.map(&:to_mathml_without_math_tag) || []
-          third_value = Utility.ox_element("mo") << (mathml_paren(parameter_three) || "")
+          third_value = Utility.ox_element("mo", attributes: options&.dig(:close_paren)) << (mathml_paren(parameter_three) || "")
           Utility.update_nodes(
             Utility.ox_element("mrow"),
             (second_value.insert(0, first_value) << third_value),
@@ -37,17 +53,41 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
+          attrs = { "m:val": (options ? options[:separators] : "") }
           d = Utility.ox_element("d", namespace: "m")
           dpr = Utility.ox_element("dPr", namespace: "m")
-          parameter = Formula.new(Array(parameter_two))
           open_paren(dpr)
+          dpr << Utility.ox_element("sepChr", namespace: "m", attributes: attrs)
           close_paren(dpr)
-          fenced_value = omml_parameter(parameter, display_style, tag_name: "e")
-          dpr << Utility.pr_element("ctrl", true, namespace: "m")
-          Utility.update_nodes(d, [dpr, fenced_value])
+          Utility.update_nodes(
+            d,
+            [
+              dpr,
+              omml_parameter(
+                Formula.new(Array(parameter_two)),
+                display_style,
+                tag_name: "e",
+              ),
+            ],
+          )
           [d]
         end
 
+        def to_unicodemath
+          return mini_sized_unicode if mini_sized?
+
+          fenced_value = parameter_two&.map do |param|
+            next param.choose_frac if choose_frac?(param)
+
+            param.to_unicodemath
+          end&.join(" ")
+          return fenced_value if choose_frac?(parameter_two.first)
+
+          fenced_value = "(#{fenced_value})" if parameter_one&.value&.include?("|")
+
+          "#{unicode_open_paren}#{fenced_value}#{unicode_close_paren}"
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           filtered_values(parameter_two).map.with_index(1) do |object, index|
             last = index == @values.length
@@ -82,6 +122,17 @@ module Plurimath
           obj.update(value_split(obj, field_values))
         end
 
+        def mini_sized?
+          parameter_one&.mini_sized? ||
+            Math::Formula.new(parameter_two)&.mini_sized? ||
+            parameter_three&.mini_sized?
+        end
+
+        def mini_sized_unicode
+          fenced_value = parameter_two&.map(&:to_unicodemath)&.join
+          "#{parameter_one.to_unicodemath}#{fenced_value}#{parameter_three.to_unicodemath}"
+        end
+
         protected
 
         def open_paren(dpr)
@@ -118,7 +169,8 @@ module Plurimath
         end
 
         def mathml_paren(field)
-          return "" if field&.value&.include?(":")
+          unicodemath_syntax = ["&#x3016;", "&#x3017;", "&#x2524;", "&#x251c;"]
+          return "" if field&.value&.include?(":") || unicodemath_syntax.include?(field&.value&.to_s)
 
           field&.value
         end
@@ -132,6 +184,45 @@ module Plurimath
           self.parameter_three = nil
           object
         end
+
+        def unicode_open_paren
+          paren = parameter_one&.to_unicodemath
+          return "├#{convert_paren_size(paren_size: options&.dig(:open_paren, :minsize))}#{paren}" if options&.key?(:open_paren)
+          return "├#{paren}" if options&.key?(:open_prefixed) && !open_or_begin?
+          return "├" if options&.key?(:open_prefixed) || paren == "{:"
+
+          paren
+        end
+
+        def unicode_close_paren
+          paren = parameter_three&.to_unicodemath
+          return "┤#{convert_paren_size(paren_size: options&.dig(:close_paren, :minsize))}#{paren}" if options&.key?(:close_paren)
+          return "┤#{paren}" if options&.key?(:close_prefixed) && !close_or_end?
+          return "┤" if options&.key?(:close_prefixed) || paren == ":}"
+
+          paren
+        end
+
+        def choose_frac?(param)
+          param&.is_a?(Math::Function::Frac) && param&.options&.key?(:choose)
+        end
+
+        def convert_paren_size(paren_size:)
+          paren = paren_size.delete_suffix("em").to_f
+          (::Math.log(paren) / ::Math.log(1.25)).round
+        end
+
+        def open_or_begin?
+          parameter_one&.value&.include?("&#x251c;") ||
+            parameter_one&.value&.include?("&#x3016;") ||
+            parameter_one&.value&.include?("{:")
+        end
+
+        def close_or_end?
+          parameter_three&.value&.include?("&#x2524;") ||
+            parameter_three&.value&.include?("&#x3017;") ||
+            parameter_three&.value&.include?(":}")
+        end
       end
     end
   end

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

@@ -28,6 +28,12 @@ module Plurimath
           array
         end
 
+        def to_unicodemath
+          first_value = "⌊" unless open_paren
+          second_value = "⌋" unless close_paren
+          "#{first_value}#{parameter_one&.to_unicodemath}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?