plurimath 0.8.16 → 0.8.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9de48dbb937f65122d95415947e417692fc0d5a11d48e7a1caa1b54f3c4465bf
-  data.tar.gz: 2f1e748929a2569b2e7b291381624648fc11a3fc2b93d44406a9a92c2fa21068
+  metadata.gz: 766097c1faa26dc82f8664fca18a302b52920df2fce4ec8395cf2f65d8a7d687
+  data.tar.gz: 35cf1a6b6a0e87fa5404b3eea87927cd69da535deeebfcd49f8db5ce1aaba8e6
 SHA512:
-  metadata.gz: c8054b884f09d830a6b7a1e98d1c5679434540f6ad018c4135654f3ea4495336aa4971e43be842def4ad0fc139664ffa477c12407cef5553c55c46f9d0f2037d
-  data.tar.gz: 852c85f6edab822fc8e880ceded6913283be3e65300069be0fd7a898b6d057bb1143fee9f1e5b182a9dee36213c564e11038cb38040b58586c5acbd16b0d063d
+  metadata.gz: 7307ab95dc0d60e6fe65c939665e08ec59902527a454427956ee17e6d2c7bc207921e529ae107d51ec0f2a2a0909cd7da260943d277a03755efc34aa01edd2d0
+  data.tar.gz: 6f050eb9cae6730e911ccae66afe0a4384ab0fade68810fa4fa176e15d5f37eef225f0b11c1409fcd10ed05e75cbf7aa6fdd10a4e18d85ab335dbb947c22d350

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/Gemfile

@@ -11,5 +11,5 @@ gem 'equivalent-xml'
 gem 'opal-rspec', "~> 1.1.0a"
 gem 'oga'
 gem 'ox'
-gem "unitsml"
+gem "unitsml", "0.2.9"
 gem "debug"

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/asciimath/parse.rb

@@ -158,6 +158,7 @@ module Plurimath
           str("") |
           (rparen.as(:rparen) >> space? >> controversial_symbols >> comma.as(:comma).maybe >> expression).repeat(1).as(:expr) |
           (power.as(:symbol) >> space? >> expression).as(:expr) |
+          table.as(:table) >> space? >> rparen.as(:rparen) >> space? >> expression.as(:expr).maybe |
           comma.as(:comma).maybe
       end
 

data/lib/plurimath/asciimath/transform.rb

@@ -900,6 +900,18 @@ module Plurimath
         Math::Formula.new(formula_array)
       end
 
+      rule(table: simple(:table),
+           rparen: simple(:rparen),
+           expr: sequence(:expr)) do
+        [
+          Math::Function::Fenced.new(
+            Math::Symbols::Paren::OpenParen.new,
+            [table],
+            Utility.asciimath_symbol_object(rparen),
+          ),
+        ] + expr.flatten.compact
+      end
+
       rule(left: simple(:left),
            left_right_value: simple(:left_right),
            right: simple(:right)) do

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

@@ -72,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)
@@ -112,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,6 +10,7 @@ module Plurimath
         fraction_group_digits: 3,
         exponent_sign: "plus",
         fraction_group: "'",
+        number_sign: "plus",
         notation: :basic,
         group_digits: 3,
         significant: 0,
@@ -38,6 +39,7 @@ module Plurimath
         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/math/core.rb

@@ -8,6 +8,13 @@ module Plurimath
         /^\n/ => "",
       }.freeze
 
+      ALL_PARAMETERS = %i[
+        parameter_one
+        parameter_two
+        parameter_three
+        parameter_four
+      ].freeze
+
       def self.inherited(subclass)
         @descendants ||= []
         @descendants << subclass
@@ -201,7 +208,7 @@ module Plurimath
         false
       end
 
-      def linebreak
+      def linebreak?
         false
       end
 
@@ -291,11 +298,15 @@ module Plurimath
         is_a?(Math::Function::UnaryFunction)
       end
 
-      def is_nary_function?;end
+      def is_nary_function?; end
+
+      def is_nary_symbol?; end
 
-      def is_nary_symbol?;end
+      def nary_intent_name; end
 
-      def nary_intent_name;end
+      def symbol?
+        is_a?(Math::Symbols::Symbol)
+      end
 
       def is_binary_function?
         is_a?(Function::BinaryFunction)
@@ -323,8 +334,56 @@ module Plurimath
         Utility.primes_constants.any? { |prefix, prime| unicodemath_field_value(field).include?(prime) }
       end
 
+      def paren?
+        false
+      end
+
+      def pretty_print_instance_variables
+        excluded_vars = [
+          :@left_right_wrapper,
+          :@temp_mathml_order,
+          :@using_default,
+          :@displaystyle,
+          :@__ordered,
+          :@__mixed,
+          :@is_mrow,
+          :@values,
+        ]
+        instance_variables.sort - excluded_vars
+      end
+
+      def to_ms_value
+        new_arr = []
+        case self
+        when Math::Symbols::Symbol
+          new_arr << (value ? value.to_s : to_unicodemath(options: {}))
+        when Math::Number, Math::Function::Text
+          new_arr << value
+        else
+          parameters_to_ms_value(new_arr)
+          if respond_to?(:value) && value.is_a?(Array)
+            new_arr << value&.map { |element| element.to_ms_value }.join(" ")
+          end
+        end
+        new_arr
+      end
+
+      def is_mstyle?
+        false
+      end
+
+      def is_mrow?
+        false
+      end
+
       private
 
+      def parameters_to_ms_value(array)
+        ALL_PARAMETERS.each do |field|
+          array << get("@#{field}")&.to_ms_value if respond_to?(field)
+        end
+      end
+
       def array_line_break_field(field, variable, obj)
         if result(field).length > 1
           updated_object_values(variable, obj: obj)
@@ -344,10 +403,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/mrow.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Formula
+      class Mrow < Formula
+        attr_accessor :is_mrow
+
+        def initialize(
+          value = [],
+          left_right_wrapper = true,
+          display_style: true,
+          input_string: nil,
+          unitsml: false
+        )
+          super
+          @is_mrow = true
+        end
+
+        def element_order=(value)
+          @value = validated_order(value, rejectable_array: ["comment"])
+        end
+
+        def content; end
+
+        def content=(value)
+          arr_value = Array(value)
+          if no_content_in?(arr_value)
+            delete_all_text
+          else
+            validate_text_order(
+              arr_value.map { |val| validate_symbols(val) unless val.strip.empty? }
+            )
+          end
+          organize_value
+        end
+
+        def is_mrow?
+          @is_mrow
+        end
+
+        private
+
+        def organize_value
+          return if value.any?(String)
+          return unless is_mrow
+
+          value.each_with_index do |element, index|
+            update_current_element(element, value, index)
+            if value[index + 1].is_a?(Math::Function::Mod)
+              update_mod_function(value, index)
+            elsif unary_function_updatable?(value, element, index)
+              unary_function_update(value, index)
+            elsif value.first.paren? && value.last.paren?
+              organize_fencing(value)
+            elsif valid_underset_function?(element)
+              value[index] = new_nary_element(element, value)
+            elsif valid_underover_function?(element)
+              replace_with_nary_function(element, value, index)
+            elsif ternary_function_third_value_present?(element)
+              element.parameter_three = value.delete_at(index + 1)
+            end
+          end
+        end
+
+        def update_current_element(element, value, index)
+          if first_and_last_values_nil?(value)
+            replace_symbols_with_parens(value)
+          elsif element.class_name == "symbol" && element.value.nil?
+            element.value = ""
+          end
+        end
+
+        def validate_text_order(value)
+          @value.each_with_index do |item, index|
+            next unless item == "text"
+
+            if value.first
+              @value[index] = value.shift
+            else
+              value.shift
+              @value.delete_at(index)
+            end
+          end
+        end
+
+        def delete_all_text
+          @value.delete("text")
+        end
+
+        def no_content_in?(value)
+          value.nil? || value.empty? || value&.all? { |val| val.strip.empty? }
+        end
+
+        def first_and_last_values_nil?(value)
+          value.first.class_name == "symbol" &&
+            value.first.value.nil? &&
+            value.last.class_name == "symbol" &&
+            value.last.value.nil?
+        end
+
+        def replace_symbols_with_parens(value)
+          value[0] = Math::Symbols::Paren::OpenParen.new
+          value[-1] = Math::Symbols::Paren::CloseParen.new
+        end
+
+        def nary_function_or_symbol?(element)
+          element.is_nary_function? || element.is_nary_symbol?
+        end
+
+        def valid_underover_function?(element)
+          element.is_a?(Math::Function::Underover) &&
+            nary_function_or_symbol?(element.parameter_one)
+        end
+
+        def valid_underset_function?(element)
+          element.is_a?(Math::Function::Underset) &&
+            nary_function_or_symbol?(element.parameter_two)
+        end
+
+        def unary_function_updatable?(value, element, index)
+          value.length > 1 &&
+              element.is_unary? &&
+              value[index + 1] &&
+              Plurimath::Utility::UNARY_CLASSES.include?(element.class_name)
+        end
+
+        def ternary_function_third_value_present?(element)
+          element.is_ternary_function? &&
+            element.any_value_exist? &&
+            element.parameter_three.nil?
+        end
+
+        def update_mod_function(value, index)
+          mod_obj = value[index + 1]
+          mod_obj.parameter_one = filter_values(
+            value.delete_at(index),
+            array_to_instance: true
+          )
+          mod_obj.parameter_two = filter_values(
+            value.delete_at(index + 1),
+            array_to_instance: true
+          )
+        end
+
+        def unary_function_update(value, index)
+          element = value.delete_at(index)
+          element.parameter_one = filter_values(
+            value.delete_at(index),
+            array_to_instance: true
+          )
+          value.insert(index, element)
+        end
+
+        def organize_fencing(value)
+          if value[1].is_a?(Math::Function::Table) && value.length == 3
+            table = value[1]
+            table.open_paren = value.shift
+            table.close_paren = value.pop
+          else
+            @value = [
+              Function::Fenced.new(value.shift, value, value.pop)
+            ]
+          end
+        end
+
+        def new_nary_element(element, value)
+          value.shift
+          nary = Plurimath::Math::Function::Nary.new(
+            element.parameter_two,
+            element.parameter_one,
+            nil,
+            filter_values(value.shift(value.length), array_to_instance: true),
+            { type: "undOvr" }
+          )
+          nary
+        end
+
+        def replace_with_nary_function(element, value, index)
+          fourth_value = value.delete_at(index + 1)
+          organize_value(fourth_value) if fourth_value.is_mrow?
+          value[index] = Math::Function::Nary.new(
+            element.parameter_one,
+            element.parameter_two,
+            element.parameter_three,
+            filter_values(fourth_value, array_to_instance: true),
+            { type: "undOvr" }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/formula/mstyle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    class Formula
+      class Mstyle < Formula
+        def displaystyle=(value)
+          @displaystyle = boolean_display_style(value)
+        end
+
+        def is_mstyle?
+          true
+        end
+      end
+    end
+  end
+end