plurimath 0.8.10 → 0.8.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 896215930a897878dac674f1be1092b3c6e8f330e20ffe218421b01e0aa98cbc
-  data.tar.gz: ad8d176647c84540c11f8ed736e5e816ec88cf65d029b605cf280e326ea7c91a
+  metadata.gz: 4c68ac69d198de23d6a021dd5d33b68cd942f95de739f92d870e70826445da59
+  data.tar.gz: 361960657e4a8a5e38a11b237744e33b9f7aa5c5eced8582f9ec9de1ca95a7b0
 SHA512:
-  metadata.gz: 2414d5501af2bd824d56e0557132ec650eb3bddfa44180e6d2561ae11f976d2c0edffc90bc00d9d442e41b31d5c2c900c9f5e16fad770b2717810ea79f2470aa
-  data.tar.gz: 124779151cac821ea29ed9d3cd12f61bd41efb1273e9912cb92377e7ee4d4854ca91906838c8cedd540f76fc8a5c9b17256651bd933bffe582ee026cc6609c8b
+  metadata.gz: 8e5af5caafefef2bde39dd2330b8291bce8a3831f891141360fb5b15c6c170576023551d3aa284b08026ae2a70d67ff43a268c12002502b72387521fde0c8b78
+  data.tar.gz: 34f049ad3c1c8ce77b9abfe0def2c29ca20c06876b0ed81f92096837d10d0e1a2fd8bf51cb5c99b73e6eb3733f7a6635ab8200406cd71cbc8278c0faaa5ce672

data/README.adoc

@@ -61,16 +61,91 @@ Or install it yourself with:
 $ gem install plurimath
 ----
 
-== Usage
+== Command Line Interface (CLI) usage
+
+=== General
+
+Plurimath provides a Command Line Interface (CLI) tool for converting between
+different math formats.
+
+NOTE: Before continuing please ensure you have the gem installed.
+
+To convert math equations between formats, use the following command followed by
+appropriate options.
+
+[source,bash]
+----
+plurimath convert [options]
+----
+
+Options available are:
+
+`-i`, `--input <INPUT>`::
+Specifies the input math equation. Should be provided within double quotes.
+
+`-f`, `--input-format <FORMAT>`::
+Specifies the input format of the equation. Defaults to `asciimath`.
+
+`-p`, `--file-path <FILE_PATH>`::
+Reads input from a file instead of the command line input. Use this for larger
+inputs or when input contains special characters.
+
+`-t`, `--output-format <FORMAT>`::
+Specifies the output format type. Defaults to `mathml`.
+
+`-m`, `--math-rendering`::
+Renders the converted equation as a math zone display tree. Boolean option
+(`true`, `false`).
+
+`-d`, `--display-style`::
+Specifies the DisplayStyle for OMML and MathML outputs only. Boolean option
+(`true`, `false`).
+
+`-s`, `--split-on-linebreak`::
+Splits MathML and OMML output into multiple equations. Boolean option (`true`,
+`false`).
+
+
+=== Convert an AsciiMath equation to MathML
+
+[source,bash]
+----
+plurimath convert -i "sqrt(x^2 + y^2)" -f asciimath -t mathml
+----
+
+=== Convert an OMML equation to MathML with DisplayStyle
+
+[source,bash]
+----
+plurimath convert -i "equation" -f omml -t mathml -d true
+----
+
+=== Convert equations from a file and output as UnicodeMath
+
+[source,bash]
+----
+plurimath convert -e <file_path> -t unicodemath
+----
+
+For more detailed information and additional options, use:
+
+[source,bash]
+----
+plurimath help convert
+----
+
+
+== Ruby API
+
 
 The central data model in Plurimath is the `Plurimath::Formula` class, which
 allows you to transform any math representation language into any other
 representation language.
 
 
-=== Conversion Examples
+=== Conversion examples
 
-==== AsciiMath Formula Example
+==== AsciiMath Formula example
 
 [source,ruby]
 ----
@@ -78,7 +153,7 @@ asciimath = "sin(1)"
 formula = Plurimath::Math.parse(asciimath, :asciimath)
 ----
 
-==== MathML Formula Example
+==== MathML Formula example
 
 [source,ruby]
 ----
@@ -93,7 +168,7 @@ MATHML
 formula = Plurimath::Math.parse(mathml, :mathml)
 ----
 
-==== LaTeX Formula Example
+==== LaTeX Formula example
 
 [source,ruby]
 ----
@@ -101,7 +176,7 @@ latex = "\\sin{1}"
 formula = Plurimath::Math.parse(latex, :latex)
 ----
 
-==== UnicodeMath Formula Example
+==== UnicodeMath Formula example
 
 [source,ruby]
 ----
@@ -109,7 +184,7 @@ unicodemath = "sin(1)"
 formula = Plurimath::Math.parse(unicodemath, :unicodemath)
 ----
 
-==== OMML Formula Example
+==== OMML Formula example
 
 [source,ruby]
 ----
@@ -137,13 +212,14 @@ OMML
 formula = Plurimath::Math.parse(omml, :omml)
 ----
 
-=== Converting to Other Formats
+
+=== Converting to other formats
 
 Once you have a `Plurimath::Math::Formula` object, you can convert it to
 AsciiMath, MathML, LaTeX, UnicodeMath, or OMML by calling the respective
 conversion function on the `Formula` object.
 
-==== AsciiMath Output Conversion
+==== AsciiMath output conversion
 
 [source,ruby]
 ----
@@ -157,7 +233,7 @@ that LaTeX does. During conversion from LaTeX to AsciiMath, if a symbol is not
 supported in AsciiMath, the LaTeX symbol will be returned.
 
 
-==== LaTeX Output Conversion
+==== LaTeX output conversion
 
 [source,ruby]
 ----
@@ -165,7 +241,7 @@ formula.to_latex
 # => "\\sin1"
 ----
 
-==== MathML Output Conversion
+==== MathML output conversion
 
 [source,ruby]
 ----
@@ -173,7 +249,7 @@ formula.to_mathml
 # => "<math xmlns='http://www.w3.org/1998/Math/MathML'><mstyle displaystyle='true'><mi>sin</mi><mn>1</mn></mstyle></math>"
 ----
 
-==== UnicodeMath Output Conversion
+==== UnicodeMath output conversion
 
 [source,ruby]
 ----
@@ -181,7 +257,7 @@ formula.to_unicodemath
 # => "sin(1)"
 ----
 
-==== OMML Output Conversion
+==== OMML output conversion
 
 [source,ruby]
 ----
@@ -189,7 +265,8 @@ formula.to_omml
 # => "<m:oMathPara xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"><m:oMath><m:f><m:fPr><m:ctrlPr /></m:fPr><m:num><m:r><m:t>sin</m:t></m:r></m:num><m:den><m:r><m:t>1</m:t></m:r></m:den></m:f></m:oMath></m:oMathPara>"
 ----
 
-== Handling Complex Mathematical Expressions
+
+==== Complex mathematical expressions
 
 Plurimath is capable of handling complex mathematical expressions with nested
 functions and operators.
@@ -197,9 +274,7 @@ functions and operators.
 This feature is particularly useful for application that requires consistent and
 accurate conversion of intricate mathematical content.
 
-=== Example of a Complex Expression
-
-Consider the following complex LaTeX expression:
+Example. Consider the following complex LaTeX expression:
 
 [source,latex]
 ----
@@ -232,13 +307,14 @@ omml = formula.to_omml
 
 
 
+== Math parse trees
 
-== Displaying the Math Parse Tree
+=== General
 
 Plurimath allows you to display the math parse tree both as `Formula` objects
 and in the math language of expression.
 
-=== Displaying as Formula Objects
+=== Displaying as Formula objects
 
 You can display the parse tree as `Formula` objects to understand the structure
 of the parsed mathematical expression.
@@ -246,14 +322,11 @@ of the parsed mathematical expression.
 [source,ruby]
 ----
 formula = Plurimath::Math.parse("sin(1)", :asciimath)
-formula.to_display(:asciimath)
-# |_ Math zone
-#   |_ "sin(1)"
-#      |_ "sin" function apply
-#         |_ "1" argument
+formula.to_display(:formula)
+# ...
 ----
 
-=== Displaying in the Math Language of Expression
+=== Displaying in the math language of expression
 
 You can also display the parse tree in the math language of expression to see
 how the expression is represented in that language.
@@ -261,11 +334,25 @@ how the expression is represented in that language.
 [source,ruby]
 ----
 formula = Plurimath::Math.parse("sin(1)", :asciimath)
+formula.to_display(:asciimath)
+# |_ Math zone
+#   |_ "sin(1)"
+#      |_ "sin" function apply
+#         |_ "1" argument
+
 formula.to_display(:latex)
 # |_ Math zone
 #   |_ "\\sin1"
 #      |_ "sin" function apply
 #         |_ "1" argument
+
+formula.to_display(:mathml)
+# |_ Math zone
+#   |_ "<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><mstyle displaystyle="true"><mrow><mi>sin</mi><mrow><mo>(</mo><mn>1</mn><mo>)</mo></mrow></mrow></mstyle></math>"
+#      |_ "<mrow><mi>sin</mi><mrow><mo>(</mo><mn>1</mn><mo>)</mo></mrow></mrow>" function apply
+#         |_ "sin" function name
+#         |_ "<mrow><mo>(</mo><mn>1</mn><mo>)</mo></mrow>" argument
+#            |_ "<mtext>1</mtext>" text
 ----
 
 // == Integration
@@ -311,11 +398,11 @@ h = 6.62607015 xx 10^(-34) "unitsml(kg*m^2*s^(-1))"
 
 ==== Step-by-Step Customization
 
-. **Parse the UnitsML Expression**
-. **Customize and Convert to AsciiMath**
-. **Customize and Convert to MathML**
-. **Customize and Convert to UnicodeMath**
-. **Customize and Convert to OMML**
+. Parse the UnitsML Expression
+. Customize and Convert to AsciiMath
+. Customize and Convert to MathML
+. Customize and Convert to UnicodeMath
+. Customize and Convert to OMML
 
 ==== Parse the UnitsML Expression
 
@@ -341,7 +428,7 @@ puts asciimath
 # Output: 'h = 6.62607015 xx 10^(-34) "unitsml(kg*m^2*s^(-1))"'
 ----
 
-==== Customize and Convert to MathML
+==== Customize and convert to MathML
 
 To customize the MathML output, you can use additional attributes and options:
 
@@ -353,7 +440,7 @@ puts mathml
 # Output: "<math xmlns='http://www.w3.org/1998/Math/MathML'><mrow><mi>h</mi><mo>=</mo><mn>6.62607015</mn><mo>×</mo><msup><mn>10</mn><mrow><mo>−</mo><mn>34</mn></mrow></msup><mtext>kg·m²·s⁻¹</mtext></mrow></math>"
 ----
 
-==== Customize and Convert to UnicodeMath
+==== Customize and convert to UnicodeMath
 
 Similarly, customize the UnicodeMath output:
 
@@ -365,7 +452,7 @@ puts unicodemath
 # Output: 'h = 6.62607015 × 10^(−34) kg·m²·s⁻¹'
 ----
 
-==== Customize and Convert to OMML
+==== Customize and convert to OMML
 
 For OMML output, you can customize the XML structure:
 
@@ -377,7 +464,7 @@ puts omml
 # Output: "<m:oMathPara xmlns:m='http://schemas.openxmlformats.org/officeDocument/2006/math'><m:oMath><m:r><m:t>h</m:t></m:r><m:r><m:t>=</m:t></m:r><m:r><m:t>6.62607015</m:t></m:r><m:r><m:t>×</m:t></m:r><m:sSup><m:sSupPr><m:ctrlPr /></m:sSupPr><m:e><m:r><m:t>10</m:t></m:r></m:e><m:sup><m:r><m:t>−34</m:t></m:r></m:sup></m:sSup><m:r><m:t>kg·m²·s⁻¹</m:t></m:r></m:oMath></m:oMathPara>"
 ----
 
-=== Complete Example Code with Customization
+=== Complete example code with customization
 
 Here's the complete code for parsing, converting, and customizing the UnitsML
 expression between different formats:
@@ -434,7 +521,7 @@ as a text string of `"__{symbol-name}"`. Plurimath can recognize it, but other
 renderers or processors would treat it as a single symbol, which is accurate.
 
 
-=== Example of Compatibility Wrapper
+=== Usage of the compatibility wrapper
 
 For a symbol like `backepsilon`.
 
@@ -466,12 +553,13 @@ In MathML:
 <mi>∍</mi>
 ----
 
-== XML Engines
 
-**Plurimath** supports two XML engines:
+== XML engines
+
+Plurimath supports two XML engines:
 
+. **Ox**: (default) A fast XML parser
 . **Oga**: A pure Ruby XML parser
-. **Ox**: A fast XML parser
 
 By default, **Ox** is used.
 
@@ -479,12 +567,13 @@ To switch to **Oga**, use the following syntax:
 
 [source,ruby]
 ----
-require "plurimath/xml_engines/oga" = load files related to Oga
-Plurimath.xml_engine = Plurimath::XmlEngine::Oga = set Oga as Plurimath XML engine
+require "plurimath/xml_engines/oga"
+Plurimath.xml_engine = Plurimath::XmlEngine::Oga
 ----
 
 You can switch back to **Ox** similarly.
 
+
 === Supported content
 
 === General

data/exe/plurimath

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "plurimath/cli"
+
+Plurimath::Cli.start(ARGV)

data/lib/plurimath/cli.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Plurimath
+  self.autoload :Math, "plurimath/math"
+
+  class Cli < Thor
+    desc "convert", "Convert between math formats"
+
+    option :input,
+           aliases: "-i",
+           desc: "Input value should be in quoted string"
+
+    option :input_format,
+           aliases: "-f",
+           default: "asciimath",
+           desc: "Input format should be in quoted string => \"asciimath\""
+
+    option :file_path,
+           aliases: "-p",
+           desc: "Reads input from a file instead of the command line input. Use this for larger inputs or when input contains special characters.",
+           force: :boolean
+
+    option :output_format,
+           aliases: "-t",
+           default: "mathml",
+           desc: "Convert to language type, Output format should be in quoted string"
+
+    option :math_rendering,
+           aliases: "-m",
+           force: :boolean,
+           default: 'false',
+           desc: "Render converted equation as math zone display tree, Boolean only"
+
+    option :display_style,
+           aliases: "-d",
+           desc: "DisplayStyle is only supported for OMML and MathML conversion, Boolean only",
+           force: :boolean
+
+    option :split_on_linebreak,
+           aliases: "-s",
+           desc: "Splits only MathML and OMML equations into multiple equations, Boolean only",
+           force: :boolean
+
+    def convert
+      input          = options[:input]
+      input_string   = options[:file_path] ? File.read(options[:file_path]) : input
+      warn_and_exit("missing generator argument --input or --file-input") unless input_string
+
+      input_format   = options[:input_format]
+      output_format  = options[:output_format]
+      formula        = Plurimath::Math.parse(input_string, input_format)
+      return puts formula.to_display(output_format.to_sym) if YAML.safe_load(options[:math_rendering])
+
+      display_style  = options[:display_style]
+      split          = options[:split_on_linebreak]
+      style          = display_style.to_s.empty? ? "true" : display_style
+      output_text = case output_format
+                    when "unicodemath"
+                      formula.to_unicodemath
+                    when "asciimath"
+                      formula.to_asciimath
+                    when "mathml"
+                      formula.to_mathml(display_style: style, split_on_linebreak: split)
+                    when "latex"
+                      formula.to_latex
+                    when "omml"
+                      formula.to_omml(display_style: style, split_on_linebreak: split)
+                    else
+                      warn_and_exit("Invalid output format: #{output_format}")
+                    end
+
+      puts output_text
+    end
+
+    no_commands do
+      def warn_and_exit(message)
+        warn(message)
+        exit 1
+      end
+    end
+  end
+end

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