plurimath 0.8.15 → 0.8.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1783cc0eadbbb06f0f9f8cf7ec7c1c67151ae7c85e5a8f6bd8d4f325a2823fc7
-  data.tar.gz: 8f59467437e61ab7e53d828256967f014eed2417400f6df29d3a9a037b7f9545
+  metadata.gz: f232ae9e7e95e99742976ce89205bd3a21269cfaf2df31941de6fbd9594aff9e
+  data.tar.gz: 93a5a1f1e6faf693ea589c17cb0429aaba81426c838ce9c993747c8db185beb4
 SHA512:
-  metadata.gz: 91199c6a3c324fd5ac78147c402ba60ff1dc972d4f99dd33006230700f0b9aa07042e38f677f8440a6873663e977c1c0f9c6db09ce04dac1206535f99cdc43da
-  data.tar.gz: f21bffba36efc43968174c803319992edde54f4cf64e9dc840d5fa7fe9637898c01068d30021b933972ce349615d82ca477dd79ff63142178bd981feb8c09fd5
+  metadata.gz: 41e48748d0e213ee5910a6e5e6fcf2d012e87bc7a0731d1036b2e432e40677460c841fe50340763cf7c8778a9ac30ed91c2f1b6795b601bb2ad843f148a2cebc
+  data.tar.gz: 5262d5b7474b0544c82937e50e1b44342d2b2b64aa85adadf4b9a5ec0f9afbbfb23db8d45e514c25745c326c22aef8eae8321ad699a803e04ed084793c9d86e3

data/.github/workflows/gen_docs.yml

@@ -9,6 +9,13 @@ on:
 jobs:
   generate_docs:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        filename:
+        - supported_parens_list.adoc
+        - supported_symbols_list.adoc
+        - intent_supported_classes.adoc
+
     steps:
     - uses: actions/checkout@v4
 
@@ -17,12 +24,7 @@ jobs:
         ruby-version: '3.3'
         bundler-cache: true
 
-    - name: Generate supported_parens_list.adoc
-      run: |
-        rm -f supported_parens_list.adoc
-        bundle exec rake supported_parens_list.adoc
-
-    - name: Generate supported_symbols_list.adoc
+    - name: Generate documentation
       run: |
-        rm -f supported_symbols_list.adoc
-        bundle exec rake supported_symbols_list.adoc
+        rm -f ${{ matrix.filename }}
+        bundle exec rake ${{ matrix.filename }}

data/README.adoc

@@ -583,6 +583,10 @@ Consult the following tables for details on supported symbols and parentheses:
 * link:supported_symbols_list.adoc[Symbols]
 * link:supported_parens_list.adoc[Parentheses]
 
+The following table shows the classes that support MathML "intent" encoding:
+
+* link:intent_supported_classes.adoc[Classes that support MathML Intent]
+
 NOTE: To regenerate these files, delete them and run:
 `bundle exec rake supported_symbols_list.adoc`.
 

data/Rakefile

@@ -18,6 +18,7 @@ end
 DOC_FILES = {
   "supported_parens_list.adoc" => :paren,
   "supported_symbols_list.adoc" => :symbols,
+  "intent_supported_classes.adoc" => :intent,
 }.freeze
 
 DOC_FILES.each do |file_name, type|
@@ -28,17 +29,26 @@ end
 
 def write_doc_file(doc_file, type:)
   File.open(doc_file, "a") do |file|
-    file.write(file_header)
-
-    Plurimath::Utility.send(:"#{type}_files").each do |klass|
-      next if klass::INPUT.empty?
-      
-      file_name = File.basename(klass.const_source_location(:INPUT).first, ".rb")
-      file.write(documentation_content(file_name, klass))
+    case type
+    when :intent
+      write_intent_doc_file(file)
+    else
+      paren_symbols_doc(file, type)
     end
+  end
+end
+
+def paren_symbols_doc(file, type)
+  file.write(file_header)
 
-    file.write("|===")
+  Plurimath::Utility.send(:"#{type}_files").each do |klass|
+    next if klass::INPUT.empty?
+
+    file_name = File.basename(klass.const_source_location(:INPUT).first, ".rb")
+    file.write(documentation_content(file_name, klass))
   end
+
+  file.write("|===")
 end
 
 def documentation_content(file_name, klass)
@@ -75,4 +85,41 @@ def format_input(format, klass)
   end.join(", ").gsub(/\|/, "\\|")
 end
 
+def write_intent_doc_file(file)
+  file.write("= List of classes supporting `intent` encoding with relevant values\n")
+
+  intent_classes.each do |klass|
+    intents = klass.new.intent_names.values.map do |intent|
+      "`#{intent}`"
+    end
+
+    file.write(
+      <<~INTENT
+
+        * `#{klass.name.gsub("Plurimath::Math::", "")}`
+        ** #{intents.join("\n** ")}
+      INTENT
+    )
+  end
+
+  file.write("\nIntent for unary classes like, sin, cos, tan, etc. will be `Function`.\n")
+end
+
+def intent_classes
+  intent_classes = [
+    Plurimath::Math::Function::TernaryFunction.descendants,
+    Plurimath::Math::Function::BinaryFunction.descendants,
+    Plurimath::Math::Function::UnaryFunction.descendants,
+    Plurimath::Math::Function::Table.descendants,
+    Plurimath::Math::Symbols::Symbol.descendants,
+    Plurimath::Math::Function::UnaryFunction,
+    Plurimath::Math::Function::Table,
+    Plurimath::Math::Function::Nary,
+    Plurimath::Math::Formula,
+  ].flatten
+  intent_classes.select do |klass|
+    klass.instance_methods(false).include?(:intent_names)
+  end
+end
+
 task :default => :spec

data/intent_supported_classes.adoc

@@ -0,0 +1,82 @@
+= List of classes supporting `intent` encoding with relevant values
+
+* `Function::Fenced`
+** `open-closed-interval`
+** `closed-open-interval`
+** `binomial-coefficient`
+** `closed-interval`
+** `open-interval`
+** `:fenced`
+
+* `Function::Int`
+** `:integral`
+
+* `Function::Oint`
+** `:contour integral`
+
+* `Function::Prod`
+** `:product`
+
+* `Function::Sum`
+** `:sum`
+
+* `Function::Frac`
+** `:derivative`
+** `:partial-derivative`
+
+* `Function::Inf`
+** `:function`
+
+* `Function::Intent`
+** `:derivative`
+
+* `Function::Lim`
+** `:function`
+
+* `Function::Abs`
+** `absolute-value`
+
+* `Symbols::Dd`
+** `ⅆ`
+
+* `Symbols::Ii`
+** `ⅈ`
+
+* `Symbols::Intercal`
+** `transpose`
+
+* `Symbols::Jj`
+** `ⅉ`
+
+* `Symbols::UpcaseDd`
+** `ⅅ`
+
+* `Function::UnaryFunction`
+** `:function`
+
+* `Function::Table`
+** `:curly-braced-matrix`
+** `:parenthesized-matrix`
+** `:bracketed-matrix`
+** `:normed-matrix`
+** `:determinant`
+** `:equations`
+** `:cases`
+
+* `Function::Nary`
+** `:n-ary`
+** `:anticlockwise contour integral`
+** `:coproduct`
+** `:quadruple integral`
+** `:triple integral`
+** `:double integral`
+** `:clockwise contour integral`
+** `:volume integral`
+** `:surface integral`
+** `:contour integral`
+
+* `Formula`
+** `:partial-derivative`
+** `:derivative`
+
+Intent for unary classes like, sin, cos, tan, etc. will be `Function`.

data/lib/plurimath/formatter/number_formatter.rb

@@ -3,7 +3,7 @@
 module Plurimath
   module Formatter
     class NumberFormatter
-      attr_reader :number, :data_reader
+      attr_reader :number, :data_reader, :prefix
 
       STRING_SYMBOLS = {
         dot: ".".freeze,
@@ -13,6 +13,7 @@ module Plurimath
       def initialize(number, data_reader = {})
         @number = number
         @data_reader = data_reader
+        @prefix = "-" if number.negative?
       end
 
       def format(precision: nil)
@@ -20,16 +21,15 @@ module Plurimath
         int, frac, integer_format, fraction_format, signif_format = *partition_tokens(number)
         result = integer_format.apply(int, data_reader)
         result << fraction_format.apply(frac, data_reader, int) if frac
-
         result = signif_format.apply(result, integer_format, fraction_format)
-
-        result
+        result = "+#{result}" if number.positive? && data_reader[:number_sign] == :plus
+        "#{prefix}#{result}"
       end
 
       private
 
       def partition_tokens(number)
-        int, fraction = parse_number(number, data_reader)
+        int, fraction = parse_number(number)
         [
           int,
           fraction,
@@ -46,7 +46,7 @@ module Plurimath
         parts.size == 2 ? parts[1].size : 0
       end
 
-      def parse_number(number, options = {})
+      def parse_number(number, options = data_reader)
         precision = options[:precision] || precision_from(number)
 
         num = if precision == 0

data/lib/plurimath/formatter/numeric_formatter.rb

@@ -1,9 +1,4 @@
-require_relative "supported_locales"
-require_relative "numbers/base"
-require_relative "numbers/integer"
-require_relative "numbers/fraction"
-require_relative "numbers/significant"
-require_relative "number_formatter"
+# frozen_string_literal: true
 
 module Plurimath
   module Formatter
@@ -77,7 +72,9 @@ module Plurimath
 
       def update_exponent_value(number_str)
         exponent_number = BigDecimal(number_str) - 1
-        "#{"+" if @exponent_sign == :plus}#{exponent_number.to_i}"
+        return exponent_number.to_i if exponent_number.negative? || @exponent_sign != :plus
+
+        "+#{exponent_number.to_i}"
       end
 
       def notation_chars(num_str)
@@ -117,7 +114,8 @@ module Plurimath
 
         chars.first.delete!(".")
         chars.first.insert(index + 1, ".") unless chars.first[index + 2].nil?
-        chars[-1] = (chars[-1].to_i - index).to_s
+        exponent = chars[-1]
+        chars[-1] = "#{"+" if exponent.to_s.start_with?("+")}#{exponent.to_i - index}"
       end
     end
   end

data/lib/plurimath/formatter/standard.rb

@@ -10,10 +10,12 @@ module Plurimath
         fraction_group_digits: 3,
         exponent_sign: "plus",
         fraction_group: "'",
+        number_sign: "plus",
         notation: :basic,
         group_digits: 3,
         significant: 0,
         digit_count: 0,
+        precision: 0,
         decimal: ".",
         group: ",",
         times: "x",
@@ -21,21 +23,23 @@ module Plurimath
       }.freeze
 
       def initialize(locale: "en", string_format: nil, options: {}, precision: nil)
-        @precision = precision
         super(
           locale,
           localize_number: string_format,
           localizer_symbols: set_default_options(options),
+          precision: precision,
         )
       end
 
       def set_default_options(options)
         default_options = self.class::DEFAULT_OPTIONS
+        self.precision ||= default_options[:precision]
         options ||= default_options
         options[:fraction_group_digits] ||= default_options[:fraction_group_digits]
         options[:fraction_group] ||= default_options[:fraction_group]
         options[:exponent_sign] ||= default_options[:exponent_sign]
         options[:group_digits] ||= default_options[:group_digits]
+        options[:number_sign] ||= default_options[:number_sign]
         options[:significant] ||= default_options[:significant]
         options[:notation] ||= default_options[:notation]
         options[:decimal] ||= default_options[:decimal]

data/lib/plurimath/formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "formatter/numeric_formatter"
+require_relative "formatter/supported_locales"
+require_relative "formatter/numbers/base"
+require_relative "formatter/numbers/integer"
+require_relative "formatter/numbers/fraction"
+require_relative "formatter/numbers/significant"
+require_relative "formatter/number_formatter"
+
+module Plurimath
+  module Formatter
+  end
+end

data/lib/plurimath/latex/parse.rb

@@ -97,7 +97,8 @@ module Plurimath
           rparen.absent? >> symbol_class_commands |
           (slash >> math_operators_classes) |
           match["a-zA-Z"].as(:symbols) |
-          match(/\d+(\.[0-9]+)|\d/).repeat(1).as(:number) |
+          (match["0-9"].repeat(0) >> str(".").maybe >> match["0-9"].repeat(1)).as(:number) |
+          match["0-9"].repeat(1).as(:number) |
           (str("\\\\").as("\\\\") >> match(/\s/).repeat) |
           str("\\ ").as(:space) |
           (str("\\operatorname{") >> match("[^}]").repeat.as(:symbols) >> str("}"))

data/lib/plurimath/math/core.rb

@@ -344,10 +344,10 @@ module Plurimath
         ox_element("mrow") << xml_engine_node
       end
 
-      def intentify(tag, intent, func_name:, intent_name: nil)
+      def intentify(tag, intent, func_name:, intent_name: nil, options: {})
         return tag unless intent
 
-        Utility::IntentEncoding.send("#{func_name}_intent", tag, intent_name)
+        Utility::IntentEncoding.send("#{func_name}_intent", tag, intent_name, options)
       end
 
       def masked_tag(tag)

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, :unitsml
+      attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string, :unitsml, :unitsml_xml
 
       MATH_ZONE_TYPES = %i[
         omml
@@ -48,8 +48,14 @@ module Plurimath
         parse_error!(:asciimath)
       end
 
-      def to_mathml(display_style: displaystyle, split_on_linebreak: false, intent: false, formatter: nil)
-        options = { formatter: formatter }
+      def to_mathml(
+        intent: false,
+        formatter: nil,
+        unitsml_xml: nil,
+        split_on_linebreak: false,
+        display_style: displaystyle
+      )
+        options = { formatter: formatter, unitsml_xml: unitsml_xml }
         return line_breaked_mathml(display_style, intent, options: options) if split_on_linebreak
 
         math_attrs = {
@@ -80,6 +86,7 @@ module Plurimath
         attributes = intent_attribute(mathml_value) if intent
         mrow = ox_element("mrow", attributes: attributes)
         mrow[:unitsml] = true if unitsml
+        mathml_value += wrapped_unitsml_xml(mrow) if unitsml_xml && options[:unitsml_xml]
         Utility.update_nodes(mrow, mathml_value)
       end
 
@@ -290,6 +297,13 @@ module Plurimath
         true if value&.first&.mini_sized?
       end
 
+      def intent_names
+        {
+          partial_derivative: ":partial-derivative",
+          derivative: ":derivative",
+        }
+      end
+
       protected
 
       def boolean_display_style(display_style = displaystyle)
@@ -329,6 +343,12 @@ module Plurimath
         end
       end
 
+      def wrapped_unitsml_xml(mrow)
+        node = Plurimath.xml_engine.load("<mrow>#{unitsml_xml}</mrow>")
+        mrow.attributes[:xref] = node.locate("*/@id").first if node.locate("*/@id").any?
+        node.nodes
+      end
+
       def space_element(node)
         element = (ox_element("mo") << "&#x2062;")
         element[:rspace] = "thickmathspace" if text_in_tag?(node.xml_nodes.nodes)
@@ -476,7 +496,7 @@ module Plurimath
           prime_str = encode(nodes.last.nodes.first) if valid_prime?(nodes.last)
           second_arg.insert(-1, prime_str) unless second_arg.match?(/[0-9]$/)
         end
-        ":partial-derivative(#{first_arg},$f,#{second_arg})"
+        "#{intent_names[:partial_derivative]}(#{first_arg},$f,#{second_arg})"
       end
 
       def f_arg(tag_nodes, index)
@@ -548,7 +568,7 @@ module Plurimath
           end
           break
         end
-        intent_name = ":derivative(1,#{second_arg},#{third_arg})"
+        intent_name = "#{intent_names[:derivative]}(1,#{second_arg},#{third_arg})"
         mrow = ox_element("mrow", attributes: { intent: intent_name })
         nodes.insert(0, Utility.update_nodes(mrow, mrow_nodes))
       end
@@ -563,7 +583,7 @@ module Plurimath
 
           if DERIVATIVE_CONSTS.include?(node.nodes[0]&.nodes&.first)
             iteration += 1
-            node["intent"] = ":derivative#{derivative_intent_name(node.nodes[1], nodes[iteration..-1], type: node.name)}"
+            node["intent"] = "#{intent_names[:derivative]}#{derivative_intent_name(node.nodes[1], nodes[iteration..-1], type: node.name)}"
             next_node = nodes[iteration]
             case next_node.name
             when "mi", "mrow"

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

@@ -14,7 +14,7 @@ module Plurimath
           first_value = first_value&.insert(0, symbol) unless open_paren
           first_value << symbol unless close_paren
           mrow = Utility.update_nodes(ox_element("mrow"), first_value)
-          intentify(mrow, intent, func_name: :abs, intent_name: :"absolute-value")
+          intentify(mrow, intent, func_name: :abs, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -39,6 +39,10 @@ module Plurimath
           "⒜#{unicodemath_parens(parameter_one, options: options)}"
         end
 
+        def intent_names
+          { name: "absolute-value" }
+        end
+
         protected
 
         def md_tag

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

@@ -39,6 +39,7 @@ module Plurimath
             intent,
             func_name: :interval_fence,
             intent_name: intent_value(mrow_value, options: options),
+            options: intent_names,
           )
         end
 
@@ -145,6 +146,17 @@ module Plurimath
           "#{parameter_one.to_unicodemath(options: options)}#{fenced_value}#{parameter_three.to_unicodemath(options: options)}"
         end
 
+        def intent_names
+          {
+            open_closed_interval: "open-closed-interval",
+            closed_open_interval: "closed-open-interval",
+            binomial_coefficient: "binomial-coefficient",
+            closed_interval: "closed-interval",
+            open_interval: "open-interval",
+            fenced: ":fenced",
+          }
+        end
+
         protected
 
         def open_paren(dpr, options:)
@@ -253,11 +265,11 @@ module Plurimath
         end
 
         def intent_value(value, options:)
-          return "binomial-coefficient" if binomial_coefficient?(value)
+          return :binomial_coefficient if binomial_coefficient?(value)
 
           open_paren = symbol_or_paren(parameter_one, lang: :latex, options: options)
           close_paren = symbol_or_paren(parameter_three, lang: :latex, options: options)
-          return "fenced" unless interval_intent?(value, open_paren, close_paren)
+          return :fenced unless interval_intent?(value, open_paren, close_paren)
 
           interval_intent(value, open_paren, close_paren)
         end
@@ -270,15 +282,15 @@ module Plurimath
         def interval_intent(value, open_paren, close_paren)
           case open_paren
           when "("
-            'open-closed-interval' if close_paren == ']'
+            :open_closed_interval if close_paren == ']'
           when "["
-            return 'closed-interval' if close_paren == ']'
+            return :closed_interval if close_paren == ']'
 
-            'closed-open-interval' if (close_paren == '[' || close_paren == ')')
+            :closed_open_interval if (close_paren == '[' || close_paren == ')')
           when "]"
-            return 'open-closed-interval' if close_paren == ']'
+            return :open_closed_interval if close_paren == ']'
 
-            'open-interval' if close_paren == '['
+            :open_interval if close_paren == '['
           end
         end
 

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

@@ -41,7 +41,7 @@ module Plurimath
           frac_tag.set_attr(self.options.reject { |opt| opt == :choose }) if tag_name == "mfrac" && self.options
           Utility.update_nodes(frac_tag, mathml_value)
           update_derivative(frac_tag, mathml_value[0], mathml_value[1]) if intent
-          intentify(frac_tag, intent, func_name: :frac)
+          intentify(frac_tag, intent, func_name: :frac, options: intent_names)
         end
 
         def to_latex(options:)
@@ -98,6 +98,13 @@ module Plurimath
           "#{first_value}⒞#{second_value}"
         end
 
+        def intent_names
+          {
+            derivative: ":derivative",
+            partial_derivative: ":partial-derivative",
+          }
+        end
+
         protected
 
         def fpr_element

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

@@ -36,7 +36,7 @@ module Plurimath
               parameter_two&.to_mathml_without_math_tag(intent, options: options),
             ],
           )
-          intentify(inf_tag, intent, func_name: :function, intent_name: :function)
+          intentify(inf_tag, intent, func_name: :function, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -57,6 +57,10 @@ module Plurimath
           "inf#{sub_value(options: options)}#{sup_value(options: options)}"
         end
 
+        def intent_names
+          { name: ":function" }
+        end
+
         protected
 
         def sup_value(options:)

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

@@ -62,7 +62,7 @@ module Plurimath
               wrap_mrow(parameter_three&.to_mathml_without_math_tag(intent, options: options), intent),
             ].flatten.compact,
           )
-          intentify(mrow, intent, func_name: :naryand, intent_name: :integral)
+          intentify(mrow, intent, func_name: :naryand, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -116,6 +116,10 @@ module Plurimath
           true
         end
 
+        def intent_names
+          { name: ":integral" }
+        end
+
         protected
 
         def sup_value(options:)

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

@@ -17,15 +17,19 @@ module Plurimath
           "ⓘ#{first_value}"
         end
 
+        def intent_names
+          { name: ":derivative" }
+        end
+
         private
 
         def encoded_intent(tag)
-          if parameter_two.value == ":derivative" && encodable?
+          if parameter_two.value == intent_names[:name] && encodable?
             field = parameter_one.value
             unicode = encode(field[0].parameter_one.value)
             unfenced_str = fence_value(tag.nodes[1].nodes[1..-2]) if tag.nodes[1]["intent"] == ":fenced"
             fenced_str = "(#{unfenced_str})" unless unfenced_str.empty?
-            ":derivative(1,#{unicode}#{fenced_str},#{unfenced_str})"
+            "#{intent_names[:name]}(1,#{unicode}#{fenced_str},#{unfenced_str})"
           else
             Utility.html_entity_to_unicode(parameter_two.value)
           end

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

@@ -42,7 +42,7 @@ module Plurimath
               parameter_two&.to_mathml_without_math_tag(intent, options: options),
             ],
           )
-          intentify(lim_tag, intent, func_name: :function, intent_name: :function)
+          intentify(lim_tag, intent, func_name: :function, intent_name: intent_names[:name])
         end
 
         def to_omml_without_math_tag(display_style, options:)
@@ -64,6 +64,10 @@ module Plurimath
             self.parameter_two = nil
           end
         end
+
+        def intent_names
+          { name: ":function" }
+        end
       end
     end
   end