plurimath 0.8.0 → 0.8.2

data/UnitsML-Supported-Data.adoc

@@ -0,0 +1,444 @@
+== UnitsML Support
+
+=== UNITS
+
+* `ton-force (2000 lb)` => `ton-force (2000 lb)`
+* `fl oz (US label)` => `fl oz (US label)`
+* `e^2*a_0^2*(E_h)^-1` => `𝑒²𝑎₀²/𝐸ₕ`
+* `oz (US label)` => `oz (US label)`
+* `liq pint (US)` => `liq pint (US)`
+* `e^3a_0^3*(E_h^3)` => `𝑒³𝑎₀³𝐸ₕ³`
+* `e^4a_0^4*(E_h^3)` => `𝑒⁴𝑎₀⁴𝐸ₕ⁴`
+* `in^3_section_modulus` => `in³`
+* `e^2*a_0^2*m_e-1` => `𝑒²𝑎₀²/𝑚ₑ`
+* `h-bar*(e*a_0^2)-1` => `ℏ/𝑒𝑎₀²`
+* `e^2*(a_0*E_h)-1` => `𝑒²/𝑎₀𝐸ₕ`
+* `dry pt (US)` => `dry pt (US)`
+* `J*mol^-1*K^-1` => `J/(mol·K)`
+* `dry qt (US)` => `dry qt (US)`
+* `statcoulomb` => `statcoulomb`
+* `liq qt (US)` => `liq qt (US)`
+* `a_0*E_h*h-bar-1` => `𝑎₀𝐸ₕ/ℏ`
+* `W*m^-2*sr^-1` => `W/(m²·sr)`
+* `kcal_th*s^-1` => `kcal_th/s`
+* `h-bar*(m_e*c^2)` => `ℏ/𝑚ₑ𝑐²`
+* `E_h*(e*a_0^2)` => `𝐸ₕ/𝑒𝑎₀²`
+* `ton_refrigeration` => `ton`
+* `dwt (troy)` => `dwt (troy)`
+* `J*kg^-1*K^-1` => `J/(kg·K)`
+* `fl oz (UK)` => `fl oz (UK)`
+* `fl oz (US)` => `fl oz (US)`
+* `h-bar*e*(m_e)-1` => `ℏ𝑒/𝑚ₑ`
+* `dprime_Hg_60degF` => `″Hg`
+* `dprime_Hg_32degF` => `″Hg`
+* `ft*lbf*s^-1` => `ft·lbf/2`
+* `cal_th*s^-1` => `cal_th/s`
+* `N*m^2*kg^-2` => `N·m²/kg²`
+* `W*m^-2*K^-1` => `W/(m²·K)`
+* `eE_h*h-bar^-1` => `𝑒𝐸ₕ/ℏ`
+* `ftH_2O_39degF` => `ftH₂O`
+* `h-bar*(E_h)-1` => `ℏ/𝐸ₕ`
+* `dr (avdp)` => `dr (avdp)`
+* `scr (ap.)` => `scr (ap.)`
+* `W*m^-1*K^-1` => `W/(m·K)`
+* `kgf*s^2/m` => `kgf·s²m⁻¹`
+* `kg*m^2*s^-1` => `kg·m²/s`
+* `inH_2O_39degF` => `inH₂O`
+* `inH_2O_60degF` => `inH₂O`
+* `E_h*(e*a_0)` => `𝐸ₕ/𝑒𝑎₀`
+* `ft^3*min^-1` => `ft³min`
+* `kgf*m*s^-1` => `kgf·m/s`
+* `ft*min^-1` => `ft·min⁻¹`
+* `dyn*cm^-2` => `dyn·cm⁻²`
+* `kgf*cm^-2` => `kgf·cm⁻²`
+* `kgf*mm^-2` => `kgf·mm⁻²`
+* `mi*min^-1` => `mi·min⁻¹`
+* `cmH_2O_4degC` => `cmH₂O`
+* `ft^3*sec^-1` => `ft³sec`
+* `in^3*min^-1` => `in³min`
+* `E_h*(a_0)-1` => `𝐸ₕ/𝑎₀`
+* `h-bar*(a_0)-1` => `ℏ/𝑎₀`
+* `a_tropical_year` => `a`
+* `cwt (US)` => `cwt (US)`
+* `cwt (UK)` => `cwt (UK)`
+* `bbl (US)` => `bbl (US)`
+* `gal (US)` => `gal (US)`
+* `gal (UK)` => `gal (UK)`
+* `thm (EC)` => `thm (EC)`
+* `rad_radiation` => `rad`
+* `thm (US)` => `thm (US)`
+* `statwatt` => `statwatt`
+* `a_sidereal_year` => `a`
+* `mol*kg^-1` => `mol/kg`
+* `pica_computer` => `pc`
+* `lambda-bar_C` => `ƛ_C`
+* `aW (Cardelli)` => `aW`
+* `mol*m^-3` => `mol·m⁻³`
+* `erg*s^-1` => `erg·s⁻¹`
+* `kgf*m^-2` => `kgf·m⁻²`
+* `gf*cm^-2` => `gf·cm⁻²`
+* `inHg_60degF` => `inHg`
+* `inHg_32degF` => `inHg`
+* `min_sidereal` => `min`
+* `m_e*c^2_MeV` => `𝑚ₑ𝑐²`
+* `mi_US_survey` => `mi`
+* `statohm` => `statohm`
+* `ft^2*s^-1` => `ft²/s`
+* `kat*m^-3` => `kat/m³`
+* `kcal_IT` => `kcal_IT`
+* `kcal_th` => `kcal_th`
+* `rad*s^-2` => `rad/s²`
+* `cmHg_0degC` => `cmHg`
+* `lb*ft^-3` => `lb/ft³`
+* `pt (UK)` => `pt (UK)`
+* `bu (US)` => `bu (US)`
+* `kg*m*s^-1` => `N·m/s`
+* `statmho` => `statmho`
+* `pica_printer` => `pc`
+* `yd_US_survey` => `yd`
+* `tbsp_label` => `tbsp`
+* `ft_US_survey` => `ft`
+* `in_US_survey` => `in`
+* `qt (UK)` => `qt (UK)`
+* `m_e*c_MeV/C` => `𝑚ₑ𝑐`
+* `gal*min^-1` => `gpm`
+* `rad*m^-1` => `rad/m`
+* `hp_electric` => `hp`
+* `cd*m^-2` => `cd·m⁻²`
+* `ft*s^-1` => `ft·s⁻¹`
+* `in*s^-1` => `in·s⁻¹`
+* `mi*h^-1` => `mi·h⁻¹`
+* `mi*s^-1` => `mi·s⁻¹`
+* `kg*m^-3` => `kg·m⁻³`
+* `J*mol^-1` => `J/mol`
+* `rad*s^-1` => `rad/s`
+* `"Hg_32degF` => `″Hg`
+* `pt_computer` => `pt`
+* `"Hg_60degF` => `″Hg`
+* `Btu_39degF` => `Btu`
+* `Btu_59degF` => `Btu`
+* `Btu_60degF` => `Btu`
+* `h-bar_atomic` => `ℏ`
+* `gi_imperial` => `gi`
+* `mol*L^-1` => `mol/L`
+* `mol*l^-1` => `mol/l`
+* `e*(a_0^3)` => `𝑒𝑎₀³`
+* `m_e_atomic` => `𝑚ₑ`
+* `mi/gal` => `mi/gal`
+* `statWb` => `statWb`
+* `tsp_label` => `tsp`
+* `ft*s^-2` => `ft/s²`
+* `kg*m^-2` => `kg/m²`
+* `cal_IT` => `cal_IT`
+* `cal_th` => `cal_th`
+* `ft*lbf` => `ft·lbf`
+* `m^2*s^-1` => `m²/s`
+* `m^3*s^-1` => `m³/s`
+* `lbf*in^-2` => `psi`
+* `cup_label` => `cup`
+* `dprime_Hg` => `″Hg`
+* `Btu_th` => `Btu_th`
+* `pt_printer` => `pt`
+* `E_h*e-1` => `𝐸ₕ/𝑒`
+* `mil_nato` => `mil`
+* `Btu_mean` => `Btu`
+* `h-bar_eV_s` => `ℏ`
+* `hp_boiler` => `hp`
+* `W*sr^-1` => `W/sr`
+* `J*kg^-1` => `J/kg`
+* `m*s^-1` => `m·s⁻¹`
+* `m^3*kg` => `m³·kg`
+* `m*s^-2` => `m·s⁻²`
+* `A*m^-2` => `A·m⁻²`
+* `A*m^-1` => `A·m⁻¹`
+* `C*kg^-1` => `C/kg`
+* `Gy*s^-1` => `Gy/s`
+* `Np*s^-1` => `Np/s`
+* `Pa*K^-1` => `Pa/K`
+* `kg*s^-1` => `kg/s`
+* `kg*m^-1` => `kg/m`
+* `kg*m^2` => `kg·m²`
+* `kg*l^-1` => `kg/l`
+* `hp_metric` => `hp`
+* `mmH_2O` => `mmH₂O`
+* `ftH_2O` => `ftH₂O`
+* `cmH_2O` => `cmH₂O`
+* `inH_2O` => `inH₂O`
+* `prime_Hg` => `′Hg`
+* `d_sidereal` => `d`
+* `h_sidereal` => `h`
+* `s_sidereal` => `s`
+* `m_e*c^2` => `𝑚ₑ𝑐²`
+* `e*a_0^2` => `𝑒𝑎₀²`
+* `gpm` => `gal/min`
+* `J*m^-3` => `J/m³`
+* `W*m^-2` => `W/m²`
+* `kgf*m` => `kgf·m`
+* `fermi` => `fermi`
+* `dprime_in` => `″`
+* `abS` => `(abΩ)⁻¹`
+* `prime_min` => `′`
+* `ton_TNT` => `ton`
+* `C*m^-3` => `C/m³`
+* `C*m^-2` => `C/m²`
+* `barye` => `barye`
+* `psi` => `lbf/in²`
+* `N*m*s` => `N·m·s`
+* `t*m^-3` => `t/m³`
+* `ton_short` => `t`
+* `lbmol` => `lbmol`
+* `hp_water` => `hp`
+* `statT` => `statT`
+* `statF` => `statF`
+* `statA` => `statA`
+* `statV` => `statV`
+* `statH` => `statH`
+* `shake` => `shake`
+* `fl dr` => `fl dr`
+* `ac*ft` => `ac·ft`
+* `F*m^-1` => `F/m`
+* `V*m^-1` => `V/m`
+* `J*K^-1` => `J/K`
+* `N*m^-1` => `N/m`
+* `prime_ft` => `′`
+* `dprime_s` => `″`
+* `H*m^-1` => `H/m`
+* `ton_long` => `t`
+* `Pa^-1` => `Pa⁻¹`
+* `oz_troy` => `oz`
+* `lb_troy` => `lb`
+* `Lambert` => `L`
+* `l.y.` => `l.y.`
+* `cmHg` => `cmHg`
+* `Torr` => `torr`
+* `slug` => `slug`
+* `mmHg` => `mmHg`
+* `km/h` => `km/h`
+* `Pa*s` => `Pa·s`
+* `abohm` => `abΩ`
+* `kW*h` => `kW·h`
+* `thou` => `thou`
+* `l.w.` => `l.w.`
+* `ft.c` => `ft.c`
+* `ft.L` => `ft.L`
+* `fath` => `fath`
+* `cmil` => `cmil`
+* `tbsp` => `tbsp`
+* `minim` => `min`
+* `inHg` => `inHg`
+* `ftHg` => `ftHg`
+* `l.h.` => `l.h.`
+* `l.m.` => `l.m.`
+* `l.s.` => `l.s.`
+* `mbar` => `mbar`
+* `m_e*c` => `𝑚ₑ𝑐`
+* `e*a_0` => `𝑒𝑎₀`
+* `in^4` => `in⁴`
+* `K^-1` => `K⁻¹`
+* `yd^2` => `yd²`
+* `m^-1` => `m⁻¹`
+* `kayser` => `K`
+* `a_year` => `a`
+* `ft^2` => `ft²`
+* `in^2` => `in²`
+* `micron` => `μ`
+* `s^-1` => `s⁻¹`
+* `mi^2` => `mi²`
+* `in^3` => `in³`
+* `ft^3` => `ft³`
+* `yd^3` => `yd³`
+* `dprime` => `″`
+* `byte_B` => `B`
+* `hp_UK` => `hp`
+* `tex` => `tex`
+* `Gal` => `Gal`
+* `bel_B` => `B`
+* `mil` => `mil`
+* `bar` => `bar`
+* `'_min` => `′`
+* `abA` => `abA`
+* `abC` => `abC`
+* `abF` => `abF`
+* `abV` => `abV`
+* `A*h` => `A·h`
+* `erg` => `erg`
+* `abH` => `abH`
+* `Aring` => `Å`
+* `mol` => `mol`
+* `degC` => `°C`
+* `min` => `min`
+* `rad` => `rad`
+* `degK` => `°K`
+* `kat` => `kat`
+* `gamma` => `γ`
+* `rem` => `rem`
+* `W*h` => `W·h`
+* `W*s` => `W·s`
+* `dyn` => `dyn`
+* `kgf` => `kgf`
+* `N*m` => `N·m`
+* `rhe` => `rhe`
+* `atm` => `atm`
+* `darcy` => `d`
+* `Darcy` => `D`
+* `gon` => `gon`
+* `prime` => `′`
+* `cal` => `cal`
+* `pdl` => `pdl`
+* `N*s` => `N·s`
+* `lbf` => `lbf`
+* `J*s` => `J·s`
+* `kip` => `kip`
+* `h-bar` => `ℏ`
+* `e_h` => `𝐸ₕ`
+* `"Hg` => `″Hg`
+* `degR` => `°R`
+* `lnk` => `lnk`
+* `fur` => `fur`
+* `tsp` => `tsp`
+* `'Hg` => `′Hg`
+* `degF` => `°F`
+* `Btu` => `Btu`
+* `den` => `den`
+* `bit` => `bit`
+* `cup` => `cup`
+* `cSt` => `cSt`
+* `uin` => `μin`
+* `mpg` => `mpg`
+* `ppm` => `ppm`
+* `var` => `var`
+* `m_e` => `𝑚ₑ`
+* `'_ft` => `′`
+* `m^3` => `m³`
+* `m^2` => `m²`
+* `"_in` => `″`
+* `barn` => `b`
+* `m^4` => `m⁴`
+* `a_0` => `𝑎₀`
+* `c_0` => `𝑐₀`
+* `"_s` => `″`
+* `Ohm` => `Ω`
+* `deg` => `º`
+* `cd` => `cd`
+* `kg` => `kg`
+* `in` => `in`
+* `sr` => `sr`
+* `Pa` => `Pa`
+* `Wb` => `Wb`
+* `Bq` => `Bq`
+* `Gy` => `Gy`
+* `Sv` => `Sv`
+* `Hz` => `Hz`
+* `lm` => `lm`
+* `lx` => `lx`
+* `ha` => `ha`
+* `Bi` => `Bi`
+* `Mx` => `Mx`
+* `kp` => `kp`
+* `ft` => `ft`
+* `mi` => `mi`
+* `yd` => `yd`
+* `ph` => `ph`
+* `gr` => `gr`
+* `Ci` => `Ci`
+* `st` => `st`
+* `Gs` => `Gs`
+* `cP` => `cP`
+* `sb` => `sb`
+* `at` => `at`
+* `St` => `St`
+* `Oe` => `Oe`
+* `as` => `as`
+* `kn` => `kn`
+* `Np` => `Np`
+* `dB` => `dB`
+* `ua` => `ua`
+* `pc` => `pc`
+* `gf` => `gf`
+* `lb` => `lb`
+* `oz` => `oz`
+* `ct` => `ct`
+* `Gi` => `Gi`
+* `dr` => `dr`
+* `eV` => `eV`
+* `rd` => `rd`
+* `hp` => `hp`
+* `Da` => `Da`
+* `ch` => `ch`
+* `ac` => `ac`
+* `pH` => `pH`
+* `pk` => `pk`
+* `gi` => `gi`
+* `mL` => `mL`
+* `ml` => `ml`
+* `m` => `m`
+* `s` => `s`
+* `A` => `A`
+* `K` => `K`
+* `N` => `N`
+* `J` => `J`
+* `W` => `W`
+* `C` => `C`
+* `V` => `V`
+* `F` => `F`
+* `S` => `S`
+* `T` => `T`
+* `H` => `H`
+* `g` => `g`
+* `h` => `h`
+* `d` => `d`
+* `a` => `a`
+* `t` => `t`
+* `R` => `R`
+* `P` => `P`
+* `l` => `l`
+* `L` => `L`
+* `M` => `M`
+* `1` => `1`
+* `D` => `D`
+* `u` => `u`
+* `c` => `𝑐`
+* `e` => `𝑒`
+* `"` => `″`
+* `'` => `′`
+
+== DIMENSIONS
+
+* `dim_Theta` => `𝝧`
+* `dim_phi` => `𝞅`
+* `dim_L` => `𝖫`
+* `dim_M` => `𝖬`
+* `dim_T` => `𝖨`
+* `dim_N` => `𝖭`
+* `dim_J` => `𝖩`
+
+== PREFIX
+
+* `da` => `da`
+* `Ki` => `Ki`
+* `Mi` => `Mi`
+* `Gi` => `Gi`
+* `Ti` => `Ti`
+* `Pi` => `Pi`
+* `Ei` => `Ei`
+* `Zi` => `Zi`
+* `Yi` => `Yi`
+* `Y` => `Y`
+* `Z` => `Z`
+* `E` => `E`
+* `P` => `P`
+* `T` => `T`
+* `G` => `G`
+* `M` => `M`
+* `k` => `k`
+* `h` => `h`
+* `d` => `d`
+* `c` => `c`
+* `m` => `m`
+* `u` => `μ`
+* `n` => `n`
+* `p` => `p`
+* `f` => `f`
+* `a` => `a`
+* `z` => `z`
+* `y` => `y`

data/lib/plurimath/asciimath/transform.rb

@@ -896,6 +896,11 @@ module Plurimath
         Math::Formula.new([table] + expr.flatten.compact)
       end
 
+      rule(table: simple(:table),
+           left_right: simple(:left_right)) do
+        Math::Formula.new([table, left_right])
+      end
+
       rule(table: simple(:table),
            expr: simple(:expr)) do
         formula_array = [table]

data/lib/plurimath/math/formula.rb

@@ -288,26 +288,19 @@ module Plurimath
 
       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 }
+          if node.is_a?(Ox::Element) && node&.attributes&.dig(:unitsml)
+            pre_index = index - 1
+            pre_node = nodes[pre_index] if pre_index.zero? || pre_index.positive?
+            nodes.insert(index, space_element(node)) if valid_previous?(pre_node)
+            node.attributes.delete_if { |k, _| k == :unitsml }
           end
-
-          unitsml_post_processing(node.nodes) if !node.nodes.any?(String)
+          unitsml_post_processing(node.nodes) if node.nodes.none?(String)
         end
       end
 
-      def space_element(attributes: false)
+      def space_element(node)
         element = (ox_element("mo") << "&#x2062;")
-        element.attributes[:rspace] = "thickmathspace" if attributes
+        element.attributes[:rspace] = "thickmathspace" if text_in_tag?(node.nodes)
         element
       end
 
@@ -327,6 +320,17 @@ module Plurimath
       def unicodemath_value
         (negated_value? || mini_sized?) ? value&.map(&:to_unicodemath)&.join : value&.map(&:to_unicodemath)&.join(" ")
       end
+
+      def valid_previous?(previous)
+        return unless previous
+
+        ["mi", "mn"].include?(previous.name) ||
+          inside_tag?(previous)
+      end
+
+      def inside_tag?(previous)
+        previous&.nodes&.any? { |node| valid_previous?(node) if node.is_a?(Ox::Element) }
+      end
     end
   end
 end

data/lib/plurimath/mathml/transform.rb

@@ -191,8 +191,12 @@ module Plurimath
         elsif flatten_mrow&.first&.is_nary_function? && flatten_mrow.length == 2
           nary_function = flatten_mrow.first
           if nary_function.is_ternary_function? && nary_function.all_values_exist?
-            flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
-            flatten_mrow
+            if nary_function.respond_to?(:new_nary_function)
+              flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
+              flatten_mrow
+            else
+              Utility.filter_values(flatten_mrow)
+            end
           elsif nary_function.is_binary_function? && nary_function.any_value_exist?
             flatten_mrow[0] = nary_function.new_nary_function(flatten_mrow.delete_at(1))
             flatten_mrow

data/lib/plurimath/unicode_math/constants.rb

@@ -998,17 +998,16 @@ module Plurimath
         pprime: "″",
         prime: "′",
       }.freeze
+
       PARENTHESIS_MATRICES = {
-        multline: nil,
-        Vmatrix: "norm[",
-        vmatrix: "|",
         pmatrix: "(",
-        Bmatrix: "{",
+        vmatrix: "|",
+        Vmatrix: "norm[",
         bmatrix: "[",
+        Bmatrix: "{",
+        eqarray: nil,
         matrix: nil,
-        split: nil,
-        align: nil,
-        array: nil,
+        cases: nil,
       }.freeze
     end
   end

data/lib/plurimath/unitsml.rb

@@ -7,7 +7,7 @@ module Plurimath
 
     def initialize(text)
       @text = text
-      raise Math::ParseError.new(error_message) if text.match?(/\^(([^\s].*?[a-z]+)|(\([^-\d]+\)|[^\(\d-]+))/)
+      raise Math::ParseError.new(error_message) if text.match?(/\^(([^\s][^*\/,"]*?[a-z]+)|(\([^-\d]+\)|[^\(\d-]+))/)
     end
 
     def to_formula

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.8.0"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-08 00:00:00.000000000 Z
+date: 2024-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -60,6 +60,8 @@ files:
 - MathML-Supported-Data.adoc
 - README.adoc
 - Rakefile
+- UnicodeMath-Supported-Data.adoc
+- UnitsML-Supported-Data.adoc
 - bin/console
 - bin/setup
 - lib/plurimath.rb