plurimath 0.7.2 → 0.8.1

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/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&.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