asciimath2unitsml 0.1.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 034e77e5697ed13c58b3b172857fcbb44fcf95ee7d3f34e43772d2b8e4c70be7
-  data.tar.gz: 66702bb8b3a6abf29f55f5a4b0beb7b2860e2e19c4b1efa6866d551e6734007f
+  metadata.gz: a2279898112af9b3602b0f7ed1a713adc4130015a3f616767d364952fb87b8ff
+  data.tar.gz: 2bf900fe40159a836fed5bbbcdc7f76c7911083242e12962949b269fafe2e92d
 SHA512:
-  metadata.gz: d2f364ed5703beed771a4cf82c65abb31a6a1e913cb6a88009a9aa93adc7777775aef63384dd3f11344129bf2d7455fa432187dd1ac80f444127600554bd6737
-  data.tar.gz: 3af5ec03a1422567ddb0dbcea962bc4d5edcbc24497fbd9446a0bd542562ad82cb777e3542459e8c99c095620b2c4eb58514208234f48342a345bb571616a6ec
+  metadata.gz: 8d3c8c4ca3db1208f5764ddd0cf2ab221548dceb3ac99d69a14778bd05dc4aec07a54064ae408908aacf27f5dbdd456fbca6eb42f29cc626527d518f03ae831f
+  data.tar.gz: 3b1d4a11f5db9225b20802ab261ba67099f977a66af680a1aaa19ffe2fdb6f6bbf78f0088f5473fe7b1e23083a72a32f9e130a9fe71abe240f9f306610bdef64

data/.github/workflows/rake.yml

@@ -31,6 +31,8 @@ jobs:
             experimental: true
     steps:
       - uses: actions/checkout@master
+        with:
+          submodules: true
 
       - uses: ruby/setup-ruby@v1
         with:

data/.gitmodules

@@ -0,0 +1,4 @@
+[submodule "lib/unitsdb"]
+	branch = master
+	path = lib/unitsdb
+	url = https://github.com/unitsml/unitsdb.git

data/README.adoc

@@ -1,27 +1,76 @@
+image:https://img.shields.io/gem/v/asciimath2unitsml.svg["Gem Version", link="https://rubygems.org/gems/asciimath2unitsml"]
+image:https://github.com/plurimath/asciimath2unitsml/workflows/rake/badge.svg["Build Status", link="https://github.com/plurimath/asciimath2unitsml/actions?workflow=rake"]
+// image:https://codeclimate.com/github/plurimath/asciimath2unitsml/badges/gpa.svg["Code Climate", link="https://codeclimate.com/github/plurimath/asciimath2unitsml"]
+image:https://img.shields.io/github/issues-pr-raw/plurimath/asciimath2unitsml.svg["Pull Requests", link="https://github.com/plurimath/asciimath2unitsml/pulls"]
+image:https://img.shields.io/github/commits-since/plurimath/asciimath2unitsml/latest.svg["Commits since latest",link="https://github.com/plurimath/asciimath2unitsml/releases"]
+
 = asciimath2unitsml
 Convert Units expressions via MathML to UnitsML
 
 This gem converts 
 MathML incorporating UnitsML expressions (based on the Ascii representation provided by NIST)
 into MathML complying with https://www.w3.org/TR/mathml-units/[], with
-UnitsML markup embedded in it, and with unique identifiers for each distinct unit and dimension. 
+UnitsML markup embedded in it, and with unique identifiers for each distinct unit, prefix, and dimension. 
+Dimensions are automatically inserted corresponding to each unit.
 Units expressions are identified in MathML as `<mtext>unitsml(...)</mtext>`, which in turn
 can be identified in AsciiMath  as `"unitsml(...)"`. 
+
 The consuming document is meant to deduplicate the instances of UnitsML markup
 with the same identifier, and potentially remove them to elsewhere in the document
 or another document.
 
+== Notation
+
+The `unitsml()` expression consists of a unit string.
+The units used in `unitsml()` are taken from the UnitsDB database as updated by Ribose:
+https://github.com/unitsml/unitsdb[]. Units are given as an ASCII based code, consisting of
+multiplication or division of single units, each of which is defined as a Prefix
+(taken from https://github.com/unitsml/unitsdb/blob/master/prefixes.yaml[]),
+unit (taken from https://github.com/unitsml/unitsdb/blob/master/units.yaml[]),
+and exponent; e.g. `mm*s^-2`. 
+
 The conventions used for writing units are:
 
 * `^` for exponents, e.g. `m^-2`
-* `*` to combine two units by multiplication; e.g. `m*s^-2`. Division is not supported, use negative exponents instead
+* `*` to combine two units by multiplication; e.g. `m*s^-2`. 
+* `/` to combine two units by division;
 * `u` for μ (micro-)
 
+For more on units notation, see <<units_notation,Units Notation>>.
+
+The `unitsml()` can take additional optional parameters, giving further information for the UnitsML
+to be generated:
+
+* `unitsml(unit-string, quantity: ID)` provides the UnitsDB identifier for the quantity being measured
+(taken from https://github.com/unitsml/unitsdb/blob/master/quantities.yaml[]). For example,
+`unitsml(s, quantity: NISTq109)` indicates that the second is used to measure period duration.
+If a single quantity is associated with the unit in UnitsDB (as given in
+https://github.com/unitsml/unitsdb/blob/master/units.yaml[]), that quantity is added automatically;
+otherwise, no quantity is added unless explicitly nominated in this way.
+* `unitsml(unit-string, name: NAME)` provides a name for the unit, if one is not already available
+from UnitsDB. For example, `unitsml(cal_th/cm^2, name: langley)`.
+* `unitsml(unit-string, symbol: SYMBOL)` provides an alternate symbol for the unit, in AsciiMath.
+The unit-string gives the canonical representation of the unit, but SYMBOL is what will be rendered.
+For example, `unitsml(cal_th/cm^2, name: langley, symbol: La)`, or `unitsml(mm*s^-2, symbol: mm cdot s^-2)`.
+(All variables in SYMBOL are rendered upright, as is the default for units.)
+
+Standalone prefixes can be recognised by replacing the unit with hyphen; so `unitsml(p-)` corresponds
+to the standalone prefix "pico" (and is rendered as "p").
+
+== Rendering
+
+The output of the gem is MathML, with MathML unit expressions (expressed as `<mi>`, 
+complying with https://www.w3.org/TR/mathml-units/[MathML Units]) cross-referenced to UnitsML
+definitions embedded in the MathML.
+
 The gem follows the MathML Units convention of inserting a spacing invisible times operator
 (`<mo rspace='thickmathspace'>&#x2062;</mo>`) between any numbers (`<mn>`) and unit expressions
 in MathML, and representing units in MathML as non-italic variables (`<mi mathvariant='normal'>`).
 
-So:
+Space is not inserted between a number and a unit expression, when that unit expression wholly consists
+of punctuation: _1 m_, _1 °C_, but _9° 7′ 22″_.
+
+== Example
 
 [source]
 ----
@@ -83,14 +132,18 @@ is converted into:
 </math>
 ----
 
+== Usage
+
 The converter is run as:
 
 [source,ruby]
 ----
 c = Asciimath2UnitsML::Conv.new()
-c.Asciimath2UnitsML({Asciimath string containing "unitsml()"})
-c.MathML2UnitsML({MathML document containing <mtext>unitsml()</mtext>})
-c.MathML2UnitsML({Nokogiri parse of MathML document containing <mtext>unitsml()</mtext>})
+c.Asciimath2UnitsML(1 "unitsml(mm*s^-2)") # AsciiMath string containing UnitsML
+c.MathML2UnitsML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\
+  "<mtext>unitsml(kg^-2)</mtext></math>") # AsciiMath string containing <mtext>unitsml()</mtext>
+c.MathML2UnitsML(Nokogiri::XML("<math xmlns='http://www.w3.org/1998/Math/MathML'><mn>7</mn>"\
+  "<mtext>unitsml(kg^-2)</mtext></math>")) # Nokogiri parse of MathML document containing <mtext>unitsml()</mtext>
 ----
 
 The converter class may be initialised with options:
@@ -101,3 +154,107 @@ supplied instead; it will be encoded as XML entities. The value `:space` is rend
 as a spacing invisible times in MathML (`<mo rspace='thickmathspace'>&#x2062;</mo>`),
 and as a non-breaking space in HTML. The value `:nospace` is rendered as a non-spacing
 invisible times in MathML (`<mo>&#x2062;</mo>`), and is not rendered in HTML.
+
+[[units_notation]]
+== Units Notation
+
+The units used in `unitsml()` are taken from the UnitsDB database as updated by Ribose:
+https://github.com/unitsml/unitsdb[]. Units are given as an ASCII based code, consisting of
+multiplication or division of single units, each of which is defined as a Prefix 
+(taken from https://github.com/unitsml/unitsdb/blob/master/prefixes.yaml[]),
+unit (taken from https://github.com/unitsml/unitsdb/blob/master/units.yaml[]),
+and exponent; e.g. `mm*s^-2`. 
+
+In case of ambiguity, the interpretation with no prefix is prioritised over the interpretation
+as a unit; so `ct` is interpreted as _hundredweight_, rather than _centi-ton_. Exceptionally,
+`kg` is decomposed into kilo-gram rather than treated as a basic unit, for consistency with
+other prefixes of grams. (Prefixed units appear in UnitsDB, and are indicated as `prefixed: true`.)
+
+A unit may have multiple symbols; these are registered separately in 
+https://github.com/unitsml/unitsdb/units.yaml[units.yaml], as entries under `unit_symbols`.
+These different symbols will be recognised as the same Unit in the UnitsML markup, but
+the original symbol will be retained in the MathML expression. So an expression like `1 unitsml(mL)`
+will be recognised as referring to microlitres; the expression will be given under its canonical
+rendering `ml` in UnitsML markup, but the MathML rendering referencing that UnitsML expression
+will keep the notation `mL`.
+
+The symbols used for units can be highly ambiguous; in order to guarantee accurate parsing,
+the symbols used to data enter units are unambiguous in https://github.com/unitsml/unitsdb/units.yaml[units.yaml].
+They may be found as the entries for `unit_symbols/id` under each unit. For example, `B` is ambiguous between
+_bel_ (as in decibel) and _byte_; they are kept unambiguous by using `bel_B` and `byte_B` to refer to them,
+although they will still both be rendered as `B`.
+
+The following table is the current list of ambiguous symbols, which are disambiguated in the symbol ids used.
+This table can be generated (in Asciidoc format) through `Asciimath2UnitsML::Conv.new().ambig_units`:
+
+[cols="7*"]
+|===
+|Symbol | Unit + ID | | | | | 
+
+
+| &#8242; | minute (minute of arc): `'` | foot: `'_ft` | minute: `'_min` | minute (minute of arc): `prime` | foot: `prime_ft` | minute: `prime_min` 
+| &#8243; | second (second of arc): `"` | second: `"_s` | inch: `"_in` | second (second of arc): `dprime` | second: `dprime_s` | inch: `dprime_in` 
+| &#8243;Hg | conventional inch of mercury: `"Hg` | conventional inch of mercury: `dprime_Hg` | inch of mercury (32 degF): `"Hg_32degF` | inch of mercury (60 degF): `"Hg_60degF` | inch of mercury (32 degF): `dprime_Hg_32degF` | inch of mercury (60 degF): `dprime_Hg_60degF` 
+| hp | horsepower: `hp` | horsepower (UK): `hp_UK` | horsepower, water: `hp_water` | horsepower, metric: `hp_metric` | horsepower, boiler: `hp_boiler` | horsepower, electric: `hp_electric` 
+| Btu | British thermal unit_IT: `Btu` | British thermal unit (mean): `Btu_mean` | British thermal unit (39 degF): `Btu_39degF` | British thermal unit (59 degF): `Btu_59degF` | British thermal unit (60 degF): `Btu_60degF` | 
+| a | are: `a` | year (365 days): `a_year` | year, tropical: `a_tropical_year` | year, sidereal: `a_sidereal_year` | | 
+| d | day: `d` | darcy: `darcy` | day, sidereal: `d_sidereal` | | | 
+| inHg | conventional inch of mercury: `inHg` | inch of mercury (32 degF): `inHg_32degF` | inch of mercury (60 degF): `inHg_60degF` | | | 
+| inH~2~O | conventional inch of water: `inH_2O` | inch of water (39.2 degF): `inH_2O_39degF` | inch of water (60 degF): `inH_2O_60degF` | | | 
+| min | minute: `min` | minim: `minim` | minute, sidereal: `min_sidereal` | | | 
+| pc | parsec: `pc` | pica (printer's): `pica_printer` | pica (computer): `pica_computer` | | | 
+| t | metric ton: `t` | long ton: `ton_long` | short ton: `ton_short` | | | 
+| B | bel: `bel_B` | byte: `byte_B` | | | | 
+| cmHg | conventional centimeter of mercury: `cmHg` | centimeter of mercury (0 degC): `cmHg_0degC` | | | | 
+| cmH~2~O | conventional centimeter of water: `cmH_2O` | centimeter of water (4 degC): `cmH_2O_4degC` | | | | 
+| cup | cup (US): `cup` | cup (FDA): `cup_label` | | | | 
+| D | debye: `D` | darcy: `Darcy` | | | | 
+| ft | foot: `ft` | foot (based on US survey foot): `ft_US_survey` | | | | 
+| ftH~2~O | conventional foot of water: `ftH_2O` | foot of water (39.2 degF): `ftH_2O_39degF` | | | | 
+| gi | gill (US): `gi` | gill [Canadian and UK (Imperial)]: `gi_imperial` | | | | 
+| h | hour: `h` | hour, sidereal: `h_sidereal` | | | | 
+| &#8242;Hg | conventional foot of mercury: `'Hg` | conventional foot of mercury: `prime_Hg` | | | | 
+| __&#295;__ | natural unit of action: `h-bar` | atomic unit of action: `h-bar_atomic` | | | | 
+| __m__~e~ | natural unit of mass: `m_e` | atomic unit of mass: `m_e_atomic` | | | | 
+| in | inch: `in` | inch (based on US survey foot): `in_US_survey` | | | | 
+| K | kelvin: `K` | kayser: `kayser` | | | | 
+| L | liter: `L` | lambert: `Lambert` | | | | 
+| lb | pound (avoirdupois): `lb` | pound (troy or apothecary): `lb_troy` | | | | 
+| mi | mile: `mi` | mile (based on US survey foot): `mi_US_survey` | | | | 
+| mil | mil (length): `mil` | angular mil (NATO): `mil_nato` | | | | 
+| oz | ounce (avoirdupois): `oz` | ounce (troy or apothecary): `oz_troy` | | | | 
+| pt | point (printer's): `pt_printer` | point (computer): `pt_computer` | | | | 
+| rad | radian: `rad` | rad (absorbed dose): `rad_radiation` | | | | 
+| s | second: `s` | second, sidereal: `s_sidereal` | | | | 
+| tbsp | tablespoon: `tbsp` | tablespoon (FDA): `tbsp_label` | | | | 
+| ton | ton of TNT (energy equivalent): `ton_TNT` | ton of refrigeration (12 000 Btu_IT/h): `ton_refrigeration` | | | | 
+| tsp | teaspoon: `tsp` | teaspoon (FDA): `tsp_label` | | | | 
+| yd | yard: `yd` | yard (based on US survey foot): `yd_US_survey` | | | | 
+| &#186; | degree (degree of arc): `deg` | | | | | 
+| &#947; | gamma: `gamma` | | | | | 
+| &#956; | micron: `micron` | | | | | 
+| &#8486; | ohm: `Ohm` | | | | | 
+| &#197; | angstrom: `Aring` | | | | | 
+| &#295; | natural unit of action in eV s: `h-bar_eV_s` | | | | | 
+| ab&#937; | abohm: `abohm` | | | | | 
+| (ab&#937;)^-1^ | abmho: `abS` | | | | | 
+| aW | abwatt: `aW (Cardelli)` | | | | | 
+| b | barn: `barn` | | | | | 
+| Btu~th~ | British thermal unit_th: `Btu_th` | | | | | 
+| &#176;C | degree Celsius: `degC` | | | | | 
+| cal~IT~ | I.T. calorie: `cal_IT` | | | | | 
+| cal~th~ | thermochemical calorie: `cal_th` | | | | | 
+| &#176;F | degree Fahrenheit: `degF` | | | | | 
+| __a__~0~ | atomic unit of length: `a_0` | | | | | 
+| __c__ | natural unit of velocity: `c` | | | | | 
+| __c__~0~ | natural unit of velocity: `c_0` | | | | | 
+| __e__ | atomic unit of charge: `e` | | | | | 
+| __E__~h~ | atomic unit of energy: `e_h` | | | | | 
+| &#956;in | microinch: `uin` | | | | | 
+| &#176;K | kelvin: `degK` | | | | | 
+| kcal~IT~ | kilocalorie_IT: `kcal_IT` | | | | | 
+| kcal~th~ | kilocalorie_th: `kcal_th` | | | | | 
+| mmH~2~O | conventional millimeter of water: `mmH_2O` | | | | | 
+| &#176;R | degree Rankine: `degR` | | | | | 
+| &#x19b;~C~ | natural unit of length: `lambda-bar_C` | | | | | 
+|===

data/asciimath2unitsml.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-  
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "asciimath2unitsml/version"
@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Convert Asciimath via MathML to UnitsML"
   spec.description   = <<~DESCRIPTION
-  Convert Asciimath via MathML to UnitsML
+    Convert Asciimath via MathML to UnitsML
   DESCRIPTION
 
   spec.homepage      = "https://github.com/plurimath/asciimath2unitsml"
@@ -24,6 +24,27 @@ Gem::Specification.new do |spec|
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
+  # get an array of submodule dirs relatively to root repo
+  `git config --file .gitmodules --get-regexp '\\.path$'`
+    .split("\n")
+    .map { |kv_str| kv_str.split(" ") }
+    .each do |(_, submodule_path)|
+
+      # for each submodule, change working directory to that submodule
+      Dir.chdir(submodule_path) do
+
+        # issue git ls-files in submodule's directory
+        submodule_files = `git ls-files | grep -i '.yaml$'`.split($\)
+
+        submodule_files_paths = submodule_files.map do |filename|
+          File.join submodule_path, filename
+        end
+
+        # add relative paths to gem.files
+        spec.files += submodule_files_paths
+      end
+  end
+
   spec.add_dependency "asciimath"
   spec.add_dependency "htmlentities"
   spec.add_dependency "nokogiri", "~> 1.10.4"
@@ -39,5 +60,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "= 0.54.0"
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "rexml"
 end
 

data/lib/asciimath2unitsml.rb

@@ -1,3 +1,4 @@
 require_relative "asciimath2unitsml/version"
 require_relative "asciimath2unitsml/conv"
+require_relative "unitsdb_ruby/unitsdb"
 

data/lib/asciimath2unitsml/conv.rb

@@ -5,6 +5,8 @@ require "yaml"
 require "rsec"
 require_relative "string"
 require_relative "parse"
+require_relative "render"
+require_relative "unit"
 
 module Asciimath2UnitsML
   MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
@@ -12,145 +14,47 @@ module Asciimath2UnitsML
 
   class Conv
     def initialize(options = {})
-      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml")
-      @prefixes = flip_name_and_id(@prefixes_id)
-      @quantities = read_yaml("../unitsdb/quantities.yaml")
-      @units_id = read_yaml("../unitsdb/units.yaml")
-      @units = flip_name_and_id(@units_id)
-      #temporary
-      @units[:degC][:render] = "°C"
-      @units[:degF][:render] = "°F"
-      @units[:Ohm][:render] = "Ω"
-      @parser = parser
-      @multiplier = multiplier(options[:multiplier] || "\u00b7")
-    end
-
-    def multiplier(x)
-      case x
-      when :space
-        { html: "&#xA0;", mathml: "<mo rspace='thickmathspace'>&#x2062;</mo>" }
-      when :nospace
-        { html: "", mathml: "<mo>&#x2062;</mo>" }
-      else
-        { html: HTMLEntities.new.encode(x), mathml: "<mo>#{HTMLEntities.new.encode(x)}</mo>" }
+      @dimensions_id = read_yaml("../unitsdb/dimensions.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Dimension.new(k, v)
       end
-    end
-
-    def units_only(units)
-      units.reject { |u| u[:multiplier] }
-    end
-
-    def unit_id(text)
-      text = text.gsub(/[()]/, "")
-      "U_" +
-        (@units[text.to_sym] ? @units[text.to_sym][:id] : text.gsub(/\*/, ".").gsub(/\^/, ""))
-    end
-
-    def unit(units, origtext, normtext, dims)
-      dimid = dim_id(dims)
-      <<~END
-      <Unit xmlns='#{UNITSML_NS}' xml:id='#{unit_id(origtext)}'#{dimid ? " dimensionURL='##{dimid}'" : ""}>
-      #{unitsystem(units)}
-      #{unitname(units, normtext)}
-      #{unitsymbol(units)}
-      #{rootunits(units)}
-      </Unit>
-      END
-    end
-
-    def unitsystem(units)
-      ret = []
-      units = units_only(units)
-      units.any? { |x| @units[x[:unit].to_sym][:si] != true } and
-        ret << "<UnitSystem name='not_SI' type='not_SI' xml:lang='en-US'/>"
-      if units.any? { |x| @units[x[:unit].to_sym][:si] == true }
-        base = units.size == 1 && @units[units[0][:unit].to_sym][:type].include?("si-base")
-        ret << "<UnitSystem name='SI' type='#{base ? "SI_base" : "SI_derived"}' xml:lang='en-US'/>"
+      @prefixes_id = read_yaml("../unitsdb/prefixes.yaml").each_with_object({}) do |(k, v), m|
+        m[k] = UnitsDB::Prefix.new(k, v)
       end
-      ret.join("\n")
-    end
-
-    def unitname(units, text)
-      name = @units[text.to_sym] ? @units[text.to_sym][:name] : compose_name(units, text)
-      "<UnitName xml:lang='en'>#{name}</UnitName>"
-    end
-
-    # TODO: compose name from the component units
-    def compose_name(units, text)
-      text
-    end
-
-    def unitsymbol(units)
-      <<~END
-      <UnitSymbol type="HTML">#{htmlsymbol(units)}</UnitSymbol>
-      <UnitSymbol type="MathML">#{mathmlsymbolwrap(units)}</UnitSymbol>
-      END
-    end
-
-    def render(unit)
-      #require "byebug"; byebug if unit == "degC"
-      @units[unit.to_sym][:render] || unit
-    end
-
-    def htmlsymbol(units)
-      units.map do |u|
-        if u[:multiplier] then u[:multiplier] == "*" ? @multiplier[:html] : u[:multiplier]
-        else
-          u[:display_exponent] and exp = "<sup>#{u[:display_exponent].sub(/-/, "&#x2212;")}</sup>"
-          "#{u[:prefix]}#{render(u[:unit])}#{exp}"
-        end
-      end.join("")
-    end
-
-    def mathmlsymbol(units)
-      exp = units.map do |u|
-        if u[:multiplier] then u[:multiplier] == "*" ? @multiplier[:mathml] : "<mo>#{u[:multiplier]}</mo>"
-        else
-          base = "<mi mathvariant='normal'>#{u[:prefix]}#{render(u[:unit])}</mi>"
-          if u[:display_exponent]
-            exp = "<mn>#{u[:display_exponent]}</mn>".sub(/<mn>-/, "<mo>&#x2212;</mo><mn>")
-            "<msup><mrow>#{base}</mrow><mrow>#{exp}</mrow></msup>"
-          else
-            base
-          end
-        end
-      end.join("")
-    end
-
-    def mathmlsymbolwrap(units)
-      <<~END
-      <math xmlns='#{MATHML_NS}'>
-      <mrow>#{mathmlsymbol(units)}</mrow>
-      </math>
-      END
+      @prefixes = flip_name_and_symbol(@prefixes_id)
+      @quantities = read_yaml("../unitsdb/quantities.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Quantity.new(k, v)
+      end
+      @units_id = read_yaml("../unitsdb/units.yaml").each_with_object({}) do |(k, v), m|
+        m[k.to_s] = UnitsDB::Unit.new(k.to_s, v)
+      end
+      @units = flip_name_and_symbols(@units_id)
+      @symbols = @units.each_with_object({}) do |(k, v), m|
+        v.symbolids.each { |x| m[x] = v.symbols_hash[x] }
+      end
+      @parser = parser
+      @multiplier = multiplier(options[:multiplier] || "\u00b7")
     end
 
-    def rootunits(units)
-      return if units.size == 1
-      exp = units_only(units).map do |u|
-        prefix = " prefix='#{u[:prefix]}'" if u[:prefix]
-        exponent = " powerNumerator='#{u[:exponent]}'" if u[:exponent] && u[:exponent] != "1"
-        "<EnumeratedRootUnit unit='#{@units[u[:unit].to_sym][:name]}'#{prefix}#{exponent}/>"
-      end.join("\n")
-      <<~END
-      <RootUnits>#{exp}</RootUnits>
-      END
+    def float_to_display(f)
+      ret = f.to_f.round(1).to_s.sub(/\.0$/, "")
     end
 
     def prefix(units)
-      units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p1|
-        p = p1.to_sym
+      units.map { |u| u[:prefix] }.reject { |u| u.nil? }.uniq.map do |p|
         <<~END
-        <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p][:base]}'
-                prefixPower='#{@prefixes[p][:power]}' xml:id='#{@prefixes[p][:id]}'>
-          <PrefixName xml:lang="en">#{@prefixes[p][:name]}</PrefixName>
-          <PrefixSymbol type="ASCII">#{@prefixes[p][:symbol]}</PrefixSymbol>
+        <Prefix xmlns='#{UNITSML_NS}' prefixBase='#{@prefixes[p].base}'
+                prefixPower='#{@prefixes[p].power}' xml:id='#{@prefixes[p].id}'>
+          <PrefixName xml:lang="en">#{@prefixes[p].name}</PrefixName>
+          <PrefixSymbol type="ASCII">#{@prefixes[p].ascii}</PrefixSymbol>
+          <PrefixSymbol type="unicode">#{@prefixes[p].unicode}</PrefixSymbol>
+          <PrefixSymbol type="LaTeX">#{@prefixes[p].latex}</PrefixSymbol>
+          <PrefixSymbol type="HTML">#{htmlent @prefixes[p].html}</PrefixSymbol>
         </Prefix>
         END
       end.join("\n")
     end
 
-    def dimension(dims)
+    def dimension_components(dims)
       return if dims.nil? || dims.empty?
       <<~END
       <Dimension xmlns='#{UNITSML_NS}' xml:id="#{dim_id(dims)}">
@@ -159,9 +63,22 @@ module Asciimath2UnitsML
       END
     end
 
+        U2D = {
+      "m" => { dimension: "Length", order: 1, symbol: "L" },
+      "g" => { dimension: "Mass", order: 2, symbol: "M" },
+      "kg" => { dimension: "Mass", order: 2, symbol: "M" },
+      "s" => { dimension: "Time", order: 3, symbol: "T" },
+      "A" => { dimension: "ElectricCurrent", order: 4, symbol: "I" },
+      "K" => { dimension: "ThermodynamicTemperature", order: 5, symbol: "Theta" },
+      "degK" => { dimension: "ThermodynamicTemperature", order: 5, symbol: "Theta" },
+      "mol" => { dimension: "AmountOfSubstance", order: 6, symbol: "N" },
+      "cd" => { dimension: "LuminousIntensity", order: 7, symbol: "J" },
+      "deg" => { dimension: "PlaneAngle", order: 8, symbol: "Phi" },
+    }.freeze
+
     def units2dimensions(units)
-      norm = normalise_units(units)
-      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" }
+      norm = decompose_units(units)
+      return if norm.any? { |u| u[:unit] == "unknown" || u[:prefix] == "unknown" || u[:unit].nil? }
       norm.map do |u|
         { dimension: U2D[u[:unit]][:dimension],
           unit: u[:unit],
@@ -171,16 +88,23 @@ module Asciimath2UnitsML
     end
 
     def dimension1(u)
-      %(<#{u[:dimension]} symbol="#{u[:symbol]}" powerNumerator="#{u[:exponent]}"/>)
+      %(<#{u[:dimension]} symbol="#{u[:symbol]}" powerNumerator="#{float_to_display(u[:exponent])}"/>)
     end
 
     def dim_id(dims)
       return nil if dims.nil? || dims.empty?
-      "D_" + dims.map { |d| U2D[d[:unit]][:symbol] + (d[:exponent] == 1 ? "" : d[:exponent].to_s) }.join("")
+      dimhash = dims.each_with_object({}) { |h, m| m[h[:dimension]] = h }
+      dimsvector = %w(Length Mass Time ElectricCurrent ThermodynamicTemperature 
+                      AmountOfSubstance LuminousIntensity PlaneAngle)
+        .map { |h| dimhash.dig(h, :exponent) }.join(":")
+      id = @dimensions_id&.values&.select { |d| d.vector == dimsvector }&.first&.id and return id.to_s
+      "D_" + dims.map do |d|
+        U2D[d[:unit]][:symbol] + (d[:exponent] == 1 ? "" : float_to_display(d[:exponent]))
+      end.join("")
     end
 
-    def normalise_units(units)
-      gather_units(units_only(units).map { |u| normalise_unit(u) }.flatten)
+    def decompose_units(units)
+      gather_units(units_only(units).map { |u| decompose_unit(u) }.flatten)
     end
 
     def gather_units(units)
@@ -189,41 +113,85 @@ module Asciimath2UnitsML
         else
           m[-1] = { prefix: combine_prefixes(@prefixes[m[-1][:prefix]], @prefixes[k[:prefix]]),
                     unit: m[-1][:unit],
-                    exponent: (k[:exponent]&.to_i || 1) + (m[-1][:exponent]&.to_i || 1) }
+                    exponent: (k[:exponent]&.to_f || 1) + (m[-1][:exponent]&.to_f || 1) }
         end
       end
     end
 
-    def normalise_unit(u)
-      if @units[u[:unit].to_sym][:type]&.include?("si-base") then u
-      elsif !@units[u[:unit].to_sym][:bases] then { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
+    # treat g not kg as base unit: we have stripped the prefix k in parsing
+    # reduce units down to basic units
+    def decompose_unit(u)
+      if u[:unit].nil? then u
+      elsif u[:unit] == "g" then u
+      elsif @units[u[:unit]].system_type == "SI_base" then u
+      elsif !@units[u[:unit]].si_derived_bases
+        { prefix: u[:prefix], unit: "unknown", exponent: u[:exponent] }
       else
-        @units[u[:unit].to_sym][:bases].each_with_object([]) do |k, m|
-          m << { prefix: k["prefix"] ?
-                 combine_prefixes(@prefixes_id[k["prefix"]], @prefixes[u[:prefix]]) : u[:prefix],
-                 unit: @units_id[k["id"].to_sym][:symbol],
-                 exponent: (k["power"]&.to_i || 1) * (u[:exponent]&.to_i || 1) }
+        @units[u[:unit]].si_derived_bases.each_with_object([]) do |k, m|
+          m << { prefix: !k[:prefix].nil? && !k[:prefix].empty? ? 
+                 combine_prefixes(@prefixes_id[k[:prefix]], @prefixes[u[:prefix]]) : u[:prefix],
+                 unit: @units_id[k[:id]].symbolid,
+                 exponent: (k[:power]&.to_i || 1) * (u[:exponent]&.to_f || 1) }
         end
       end
     end
 
     def combine_prefixes(p1, p2)
       return nil if p1.nil? && p2.nil?
-      return p1[:symbol] if p2.nil?
-      return p2[:symbol] if p1.nil?
-      return "unknown" if p1[:base] != p2[:base]
-      @prefixes.each do |p|
-        return p[:symbol] if p[:base] == p1[:base] && p[:power] == p1[:power] + p2[:power]
+      return p1.symbolid if p2.nil?
+      return p2.symbolid if p1.nil?
+      return "unknown" if p1.base != p2.base
+      @prefixes.each do |_, p|
+        return p.symbolid if p.base == p1.base && p.power == p1.power + p2.power
       end
       "unknown"
     end
 
-    def unitsml(units, origtext, normtext)
+    def quantityname(id)
+      ret = ""
+      @quantities[id].names.each do |q|
+        ret += %(<QuantityName xml:lang="en-US">#{q}</QuantityName>)
+      end
+      ret
+    end
+
+    def quantity(normtext, quantity)
+      return unless @units[normtext] && @units[normtext].quantities.size == 1 || @quantities[quantity]
+      id = quantity || @units[normtext].quantities.first
+      dim = %( dimensionURL="##{@units[normtext].dimension}") if @units[normtext]&.dimension
+      <<~END
+      <Quantity xmlns='#{UNITSML_NS}' xml:id="#{id}"#{dim} quantityType="base">
+      #{quantityname(id)}
+      </Quantity>
+      END
+    end
+
+    def dimid2dimensions(normtext)
+      @dimensions_id[normtext].keys.map do |k|
+        { dimension: k,
+          symbol: U2D.values.select { |v| v[:dimension] == k }.first[:symbol],
+          exponent: @dimensions_id[normtext].exponent(k) }
+      end
+    end
+
+    def dimension(normtext)
+      return unless @units[normtext]&.dimension 
+      dims = dimid2dimensions(@units[normtext]&.dimension)
+      <<~END
+      <Dimension xmlns='#{UNITSML_NS}' xml:id="#{@units[normtext]&.dimension}">
+      #{dims.map { |u| dimension1(u) }.join("\n") }
+      </Dimension>
+      END
+    end
+
+    def unitsml(units, origtext, normtext, quantity, name)
       dims = units2dimensions(units)
       <<~END
-      #{unit(units, origtext, normtext, dims)}
+      #{unit(units, origtext, normtext, dims, name)}
       #{prefix(units)}
-      #{dimension(dims)}
+      #{dimension(normtext)}
+      #{dimension_components(dims)}
+      #{quantity(normtext, quantity)}
       END
     end
   end