© 2025 The Calendaring and Scheduling Consortium, Inc.
This document is not a CalConnect Standard. It is distributed for review and comment, and is subject to change without notice and may not be referred to as a Standard. Recipients of this draft are invited to submit, with their comments, notification of any relevant patent rights of which they are aware and to provide supporting documentation.
All rights reserved. Unless otherwise specified, no part of this publication may be reproduced or utilized otherwise in any form or by any means, electronic or mechanical, including photocopying, or posting on the internet or an intranet, without prior written permission. Permission can be requested from the address below.
The Calendaring and Scheduling Consortium, Inc.
4390 Chaffin Lane
McKinleyville
California 95519
United States of America
www.calconnect.org
The Calendaring and Scheduling Consortium (“CalConnect”) is a global non-profit organization with the aim to facilitate interoperability of collaborative technologies and tools through open standards.
CalConnect works closely with international and regional partners, of which the full list is available on our website ().
The procedures used to develop this document and those intended for its further maintenance are described in the CalConnect Directives.
In particular the different approval criteria needed for the different types of CalConnect documents should be noted. This document was drafted in accordance with the editorial rules of the CalConnect Directives.
Attention is drawn to the possibility that some of the elements of this document may be the subject of patent rights. CalConnect shall not be held responsible for identifying any or all such patent rights. Details of any patent rights identified during the development of the document will be provided in the Introduction.
Any trade name used in this document is information given for the convenience of users and does not constitute an endorsement.
This document was prepared by Technical Committee UnitsML.
UnitsML is a suite of technologies that facilitate digital processing of units of measurement and measurement quantities.
AsciiUnits is a text-based syntax for representing units of measurement in a compact and human-readable format, designed to be fully compatible with and interoperable with the UnitsML XML language.
Key features of AsciiUnits include:
Prefixes attached to unit codes are automatically recognized and processed.
Dimensions are automatically calculated based on the prefixes and units represented.
Support for mathematical operations on units and dimensions such as addition, subtraction, division, exponentiation, square root, grouping and parentheses.
Ability to add additional information such as quantity references, custom symbols, and names.
The UnitsML UnitsDB database is the basis used by AsciiUnits to define the units and prefixes available for various applications.
UCUM is a compact coding system for the representation of units of measurement, primarily designed for electronic data interchange in clinical and healthcare contexts. Originally developed by the Regenstrief Institute and adopted by HL7, UCUM is widely used in electronic health records and clinical information systems.
While AsciiUnits and UCUM (Unified Code for Units of Measure) are both text-based systems for representing units of measurement, they differ in several key aspects.
| Feature | AsciiUnits | UCUM |
|---|---|---|
| Syntax approach | Uses intuitive mathematical operators (*, /, ^) | Uses special characters (. for multiplication, / for division) |
| Readability | Designed for human readability and ease of typing | Optimized for compactness and machine processing |
| XML integration | Direct mapping to UnitsML XML | No built-in XML representation |
| Metadata support | Supports additional metadata (quantity references, custom symbols) | No metadata support |
| Dimensional analysis | Automatic dimension calculation | No built-in dimensional analysis |
| Unit | AsciiUnits | UCUM |
|---|---|---|
| Meter | m | m |
| Square meter | m^2 | m2 |
| Meter per second | m/s | m/s |
| Kilogram meter per second squared | kg*m/s^2 | kg.m/s2 |
| Millimole per liter | mmol/L | mmol/l |
QUDT (Quantities, Units, Dimensions and Types) is a semantic web framework for representing quantities, units, dimensions, and types in a consistent and interoperable manner based on RDF (Resource Description Framework) and OWL (Web Ontology Language).
QUDT is designed to support the semantic web and linked data applications, enabling interoperability between different systems and applications.
While AsciiUnits and QUDT share some similarities, they differ in their focus and implementation.
QUDT relies on RDF and OWL for its representation and does not provide a text-based syntax for representing units of measurement. AsciiUnits allows for accessible encoding of units in documents and text files, making it possible for authors to represent measurement quantities in a clear and concise manner.
AsciiUnits being a text-based syntax, is allows for conversion to and from UnitsML XML, which is a more structured and machine-readable format. This makes AsciiUnits suitable for applications where human readability and ease of typing are important, while QUDT is more focused on semantic web applications.
The Digital SI framework is an initiative to modernize the International System of Units (SI) by providing a digital representation of SI units and their relationships. It aims to enhance the accessibility and usability of SI units in digital applications, including scientific computing, data analysis, and machine learning.
The Digital SI framework provides a comprehensive set of tools and resources for representing SI units, including a digital representation of SI base and derived units, as well as a set of guidelines for using SI units in digital applications.
While AsciiUnits is designed to be a text-based syntax for representing units of measurement, the Digital SI framework focuses on providing a digital representation of SI units and their relationships. AsciiUnits can be used in conjunction with the Digital SI framework to provide a human-readable representation of SI units and their relationships, making it easier for users to work with SI units in digital applications.
AsciiUnits is designed to be compatible with and interoperable with other technologies for representing units of measurement, including UCUM, QUDT, and the Digital SI framework. It can be used in conjunction with these technologies to provide a comprehensive solution for representing units of measurement in scientific and engineering applications.
AsciiUnits syntax is designed to be simple and intuitive, allowing users to express complex unit expressions using a straightforward notation.
For the purposes of this document, the following terms and definitions apply.
standard quantity used to express a physical quantity
unit not derived from other units
unit derived from two or more basic units conjoined by multiplication or division
modifier to a unit with a fixed factor
type of measurement that is represented by a unit
distance, moment of force, temperature, energy.
basic physical quantity that can be expressed in terms of fundamental quantities
length, mass, time, plane angle.
name of a unit
abbreviated representation of a unit
reference identifier to a unit in a database
fundamental quantities to which the unit applies
AsciiUnits follows the following key principles to ensure clarity and usability in representing units.
Symbols are meant to be easily typed on standard keyboards, avoiding complex characters or symbols.
Unit representation and composure syntax should lead to exactly one interpretation, ensuring that each expression has an unambiguous meaning.
New units and new prefixes can be added to the system without changing the syntax.
AsciiUnits allows for the encoding of the following types of elements:
Unit systems
Units
Dimensions
Quantities
Prefixes in conjunction with units
A unit system is a collection of units of measure that forms a coherent framework for converting between different units of measurement.
UnitsML defines the following unit systems.
| ID | Name | Acceptable to be used in the SI system |
|---|---|---|
| SI_base | SI | true |
| SI_derived_special | SI-derived special | true |
| SI_derived_non-special | SI-derived non-special | true |
| non-SI_acceptable | non-SI but acceptable to be used together | true |
| non-SI_not_acceptable | non-SI and unacceptable to be used together | false |
Each unit in UnitsML belongs to exactly one unit system.
The AsciiUnits syntax is designed to represent a wide range of units of measurement and their combinations.
It includes:
Basic units: Simple units and prefixed units
Composite units: Units formed by combining basic units through mathematical operations
Basic units available to AsciiUnits are sourced from UnitsDB.
UnitsDB is a comprehensive database of units of measurement and their relationships, which
is used to define the units and prefixes available in AsciiUnits for various applications. UnitsDB is a part of the UnitsML project and is maintained by CalConnect TC UNITS.
A prefix is a modifier to a unit that indicates a fixed factor by which the unit is multiplied.
Prefixes can be used in conjunction with units to create prefixed units.
The BIPM SI prefixes are used in AsciiUnits, which include the following:
| Prefix | Symbol | Factor | Representations | ||||
| ASCII | MathML | HTML | LaTeX | Unicode | |||
| quetta | <mi>Q</mi> | Q | 10^30 | Q | Q | Q | Q |
| ronna | <mi>R</mi> | R | 10^27 | R | R | R | R |
| yotta | <mi>Y</mi> | Y | 10^24 | Y | Y | Y | Y |
| zetta | <mi>Z</mi> | Z | 10^21 | Z | Z | Z | Z |
| exa | <mi>E</mi> | E | 10^18 | E | E | E | E |
| peta | <mi>P</mi> | P | 10^15 | P | P | P | P |
| tera | <mi>T</mi> | T | 10^12 | T | T | T | T |
| giga | <mi>G</mi> | G | 10^9 | G | G | G | G |
| mega | <mi>M</mi> | M | 10^6 | M | M | M | M |
| kilo | <mi>k</mi> | k | 10^3 | k | k | k | k |
| hecto | <mi>h</mi> | h | 10^2 | h | h | h | h |
| deka | <mi>da</mi> | da | 10^1 | da | da | da | da |
| deci | <mi>d</mi> | d | 10^-1 | d | d | d | d |
| centi | <mi>c</mi> | c | 10^-2 | c | c | c | c |
| milli | <mi>m</mi> | m | 10^-3 | m | m | m | m |
| micro | <mi>u</mi> | u | 10^-6 | u | µ | $mu$ | μ |
| nano | <mi>n</mi> | n | 10^-9 | n | n | n | n |
| pico | <mi>p</mi> | p | 10^-12 | p | p | p | p |
| femto | <mi>f</mi> | f | 10^-15 | f | f | f | f |
| atto | <mi>a</mi> | a | 10^-18 | a | a | a | a |
| zepto | <mi>z</mi> | z | 10^-21 | z | z | z | z |
| yocto | <mi>y</mi> | y | 10^-24 | y | y | y | y |
| ronto | <mi>r</mi> | r | 10^-27 | r | r | r | r |
| quecto | <mi>q</mi> | q | 10^-30 | q | q | q | q |
| Prefix | Symbol | Factor | Representations | ||||
| ASCII | MathML | HTML | LaTeX | Unicode | |||
| kibi | <mi>Ki</mi> | Ki | 2^10 | Ki | Ki | Ki | Ki |
| mebi | <mi>Mi</mi> | Mi | 2^20 | Mi | Mi | Mi | Mi |
| gibi | <mi>Gi</mi> | Gi | 2^30 | Gi | Gi | Gi | Gi |
| tebi | <mi>Ti</mi> | Ti | 2^40 | Ti | Ti | Ti | Ti |
| pebi | <mi>Pi</mi> | Pi | 2^50 | Pi | Pi | Pi | Pi |
| exbi | <mi>Ei</mi> | Ei | 2^60 | Ei | Ei | Ei | Ei |
| zebi | <mi>Zi</mi> | Zi | 2^70 | Zi | Zi | Zi | Zi |
| yobi | <mi>Yi</mi> | Yi | 2^80 | Yi | Yi | Yi | Yi |
A dimension is a physical quantity that can be expressed in terms of fundamental quantities.
Basic dimensions are described with only one quantity. More complex dimensions require multiple quantities to be expressed.
Dimensions are represented in AsciiUnits using the dim_ prefix followed by the dimension name.
The collection of dimensions is defined in the UnitsDB database. Each dimension is represented by a unique identifier in the database, of the pattern NISTd{n}.
A quantity is a type of measurement that is represented by a unit.
Each quantity is associated with one or more quantity names, exactly one dimension, and one or more units of measurement.
The collection of quantities is defined in the UnitsDB database. Each quantity is represented by a unique identifier in the database, of the pattern NISTq{n}.
AsciiUnits is a text-based syntax for representing units of measurement.
There are two types of representable forms in AsciiUnits:
Units
Values of units
An AsciiUnits statement is a sequence of characters that represents a unit or a value of a unit.
A unit statement represented in the AsciiUnits language is composed of up to 3 types of elements in the UnitsML model structure.
Unit, which represents the unit itself
Dimension, which represents the dimension of the unit
Quantity, which represents the quantity being described
A value of a unit is a number that represents a measurement in that unit.
A value consists of a numerical component and a unit. For example, in “2.3 kg,” “2.3” is the value representing the quantity and “kg” is the unit.
AsciiUnits 1.0 does not support encoding of values of units. This may be added in a future version.
AsciiUnits statements support the use of prefixes as standalone elements.
Prefixes elements are indicated with a prefix of - after the prefix code.
Syntax:
Where,
is the prefix code
indicates that there is no unit associated with the prefix
AsciiUnits statement (for deci):
XML:
AsciiUnits statement (for deca):
XML:
AsciiUnits statements support the use of dimensions as standalone elements, that are not associated with any unit.
Dimensions elements are indicated with a prefix of dim_.
Syntax:
Where,
is the dimension code
AsciiUnits statement (for length):
XML:
Dimension elements can be expressed with mathematic operation adjustments.
The supported operations are:
* for addition
/ for subtraction
^ for power
sqrt() for square root
AsciiUnits statement (for squared length):
XML:
AsciiUnits statement (for square root of temperature):
XML:
Composed dimensions are formed by combining more than one basic dimensions through mathematical operations.
AsciiUnits statement (for temperature times squared length):
XML:
AsciiUnits supports a wide range of units, including basic units, prefixed units, and composite units.
Basic units are the fundamental units of measurement that are not derived from other units.
These units have the following characteristics:
They are defined as individual entries in the UnitsDB database.
Their RootUnit element contains a single EnumeratedRootUnit element, which represents the unit itself, with the unit attribute set to the unit name, with powerNumerator and powerDenominator set to 1.
Syntax:
Where,
is the unit code
The XML representation of an AsciiUnits basic unit is demonstrated below.
Basic units will not have a <Prefix> element since they are not prefixed units.
The <Dimension> element is automatically generated based on the unit code.
AsciiUnits statement:
XML:
AsciiUnits statement:
XML:
A prefixed unit is a unit that has a prefix attached to it, indicating a fixed factor by which the unit is multiplied.
Prefixes are defined in the UnitsDB database and are represented in the XML
representation of the unit. AsciiUnits only support prefixes defined by the BIPM in the SI Brochure, as described in
Prefixes are automatically parsed in AsciiUnits.
Syntax:
Where,
is the prefix code
is the unit code
The XML representation of an AsciiUnits prefixed unit is demonstrated below.
Prefixed units will have a <Prefix> element since they are prefixed.
The <Dimension> element is automatically generated based on the unit and the prefix.
AsciiUnits statement:
XML:
Composite units are units that are derived from two or more basic units conjoined by a mathematical operation.
Mathematical operations are represented in AsciiUnits using the following symbols:
* for multiplication
/ for division
^ for exponentiation
sqrt() for square root
() for grouping
The XML representation of an AsciiUnits composite unit:
Prefixed units inside the composite will have a <Prefix> element.
The <Dimension> element is automatically generated based on the final mathematical evaluation of the involved units and prefixes.
Units are multiplied using *
AsciiUnits statement (for ampere times coulomb):
XML:
Units are divided using /
AsciiUnits statement (for GHz per volt):
XML:
Parentheses define order of operations
AsciiUnits statement (for joule per kilogram kelvin):
XML:
Syntax:
Where,
is the unit code
is the exponent
XML:
Negative exponents are allowed.
XML:
Using sqrt() function.
AsciiUnits statement (for square root of hertz):
XML:
AsciiUnits statement (for square root of millimeter):
XML:
Realized composite units are formed by combining more than one basic unit through the above mentioned operations.
AsciiUnits statement (for joule per kilogram kelvin):
XML:
Multiple units can be represented by the same symbol. This is often differentiated according to historical or contextual usage, and in some cases they cannot be disambiguated by the context of the unit.
m can represent meter or mole.
B can represent both bel (as in decibel) and byte.
These units that are associated with multiple symbols are considered to have:
a primary unit symbol
one or more alternative unit symbols.
To ensure unambiguous identification of units, AsciiUnits uses unique identifiers for these ambiguous symbols accross units.
When using a potentially ambiguous symbol, AsciiUnits will attempt to resolve the ambiguity based on context where possible.
A comprehensive table of ambiguous unit symbols and their disambiguated identifiers is provided in
In UnitsDB, there is a notion of a “prefixed unit”, which is a unit that has a prefix attached to it (marked by prefixed: true in the UnitsDB entry).
In case of ambiguity, the interpretation with no prefix is prioritised over the interpretation as a unit.
Exceptionally, kg is decomposed into “kilo-gram” (a unit) rather than treated as a basic unit, for consistency with other prefixes of grams.
ct is interpreted as hundredweight, rather than centi-ton.
Units with multiple symbols have those symbols encoded separately in the UnitsDB
Units’ database. While different symbols can be used to reference the same Unit in UnitsML, the default unit symbol will still apply during presentation of the unit unless explicitly specified using
Metadata to a unit’s usage can be supplied after a comma after an AsciiUnits statement.
Syntax:
Where,
is the unit code
is the metadata
A unit of measurement is used to describe a quantity, and one unit can be used to measure different quantities.
The unit “meter” (m) can be used to measure length, wavelength, radius, height, displacement.
For interoperability between systems and value conversions, it is important to specify the quantity being measured. This ensures that the unit is used correctly and consistently in scientific and engineering contexts.
An AsciiUnit unit is associated with a default quantity.
If a single quantity is associated with the unit in UnitsDB, that quantity is added automatically.
Otherwise, no quantity is added unless explicitly specified as in
The unit m (meter) is associated with the quantities length, diameter, length of path, and so on in the UnitsDB database, with the length quantity being listed first. Therefore, the default quantity for m is “length”.
The XML representation of an AsciiUnits unit always includes the default quantity association in the <Quantity> element unless a different quantity is specified.
AsciiUnits statement:
XML:
AsciiUnits allows specifying the quantity a unit measures using the quantity metadata parameter, which provides the UnitsDB identifier for the quantity being measured.
Syntax:
Where,
is the unit code
is the reference to a quantity identifier or its shortname in the UnitsDB database
The AsciiUnits statement of s, quantity: NISTq109 indicates that the second is used to measure period duration.
The XML representation of an AsciiUnits unit with quantity reference includes the specific <Quantity> element that provides information about the quantity being measured.
AsciiUnits statement:
XML:
AsciiUnits statement:
XML:
In composite units, when a quantity is not explicitly specified, AsciiUnits will attempt to infer the appropriate quantity based on the unit’s dimension. This inference is based on the standard quantities defined in the UnitsDB database.
A unit with dimension L (length) will be detected to be associated with the quantity “length”.
A unit with dimension L*T^-1 will be detected to be associated with the quantity “velocity”.
AsciiUnits statement:
Given that the unit m/s is a composite unit, AsciiUnits can detect the dimension L*T^-1 (NISTd11), which allows an inference to the quantity “velocity” (NISTq12).
XML (with inferred quantity):
Composite units that lead to a detected of dimension associated with multiple
quantities will always infer the first quantity in the UnitsDB database. Composite units that lead to a dimension that is not associated with any quantity in the UnitsDB database will not be inferred.
AsciiUnits statement:
Given that the unit cd*sr*m^(-2) is a composite unit, AsciiUnits can detect the dimension L^-2*J (NISTd27), which allows an inference to the quantity “luminous flux” (NISTq47) or “luminance” (NISTq56), and the first detected quantity is always inferred since the exact quantity type is not specified.
XML (with inferred quantity):
The symbol representation of a unit can be customized using the symbol metadata parameter. This allows for the specification of a custom symbol representation for the unit.
The default symbol representation is the first symbol entry as associated to the unit in the UnitsDB database.
The unit s (NISTu3, second) is associated with the symbols s, "_s, and " in the context of time measurement.
Therefore, the default symbol for s is “s”.
The custom symbol representation is specified using the symbol metadata parameter.
This allows for the specification of a custom symbol representation for the unit in AsciiUnits format.
A custom symbol can be assigned to an AsciiUnits unit whether it is a unit of measure or a composite unit.
Syntax:
Where,
is the unit code
is the custom symbol representation in AsciiUnits format
While the unit-code gives the canonical representation of the unit, custom_symbol is what will be rendered.
unitsml(cal_th/cm^2, name: langley, symbol: La) assigns the custom symbol La to the unit cal_th/cm^2 (calorie thermal per square centimeter).
unitsml(mm*s^-2, symbol: mm cdot s^-2) assigns the custom symbol mm cdot s-2` to the unit `mm*s-2 (millimeter per second squared).
AsciiUnits statement (for candela steradian per square meter), with a custom symbol representation:
XML:
The name of a unit can be customized using the name metadata parameter. This allows for the specification of a custom name for the unit.
The default name is the first name entry as associated to the unit in the UnitsDB database.
The unit metric_ton (NISTu88, metric ton) is associated with the unit names “metric ton” and “ton”. The default name for metric_ton is the first entry, “metric ton”.
The custom name representation is specified using the name metadata parameter, allowing for the specification of a custom name representation for the unit.
This is especially relevant if the unit is a composite unit, as the custom name representation can be used to provide a more meaningful description of the unit, and when its name is not already available from UnitsDB.
Syntax:
Where,
is the unit code
is the custom name representation in AsciiUnits format
is an optional name for the unit, if one is not already available from UnitsDB.
unitsml(cal_th/cm^2, name: langley) assigns the custom name “langley” to the unit cal_th/cm^2 (calorie thermal per square centimeter).
The AsciiUnits statement (for the “metric ton” unit with a custom name “ton”), with a custom name representation:
XML:
A multiplier is the conjoining symbol that is used to combine multiple units in a composite unit.
It is typically represented as a multiplication sign (×) or a dot (·). The choice of symbol can depend on the context in which the unit is used and the conventions of the field of study.
The default AsciiUnits multiplier adopts the specified default from MathML Units, the middle dot (·) symbol.
This default multiplier symbol is rendered in various formats as:
ASCII: a single empty space
Unicode: the invisible times symbol (⁢)
MathML: middle dot (·)
LaTeX: a middle dot (\cdot)
HTML: a non-breaking space
The multiplier of a unit can be specified using the multiplier metadata parameter.
Syntax:
Where,
is the unit code
is the custom multiplier representation in AsciiUnits format. It accepts the following values:
is the default multiplier.
a spacing invisible times.
a non-spacing invisible times
is an arbitrary UTF-8 string that can be supplied instead; it will be encoded as XML entities.
The :space value is rendered as:
ASCII: a single empty space
Unicode: the invisible times symbol (⁢)
MathML: spacing invisible times (<mo rspace='thickmathspace'>⁢</mo>)
LaTeX: a non-breaking space (~)
HTML:   (non-breaking space)
The :nospace value is rendered as:
ASCII: no space
Unicode: the invisible times symbol (⁢)
MathML: non-spacing invisible times (<mo>⁢</mo>)
LaTeX: no space
HTML: no space
If the value is not one of the above, it will be treated as a custom multiplier, where an arbitrary UTF-8 string can be supplied. It will be rendered as:
ASCII: the UTF-8 string
Unicode: the UTF-8 string
MathML: the UTF-8 string with XML entities
LaTeX: the UTF-8 string
HTML: the UTF-8 string
The xx character is the AsciiMath explicit multiplication sign (×). This statement will render the unit as cm xx s^-2 in AsciiUnits format..
AsciiUnits can be embedded within AsciiMath using the unitsml() expression. This provides a way to incorporate UnitsML markup within mathematical content.
The Plurimath library converts AsciiMath containing AsciiUnits into MathML that incorporates UnitsML expressions complying with , with unique identifiers for each distinct unit, prefix, and dimension.
Units expressions are identified in MathML as <mtext>unitsml(...)</mtext>, which in turn can be identified in AsciiMath as "unitsml(…)".
The unitsml(...) expression consists of a unit string following the AsciiUnits syntax.
Syntax:
Where,
is the unit string, which can be a single unit or a combination of units, prefixes, and dimensions.
is an optional comma-separated list of unit metadata parameters, described in
The AsciiMath with AsciiUnits expression for “millimeters per second squared” is represented as:
The "…" is an AsciiMath expression for string, which ensures backwards compatibility with AsciiMath parsers that are not UnitsML aware.
The unitsml() expression can take additional parameters as defined in
AsciiUnits in AsciiMath can be converted into a combination of UnitsML in MathML.
MathML unit expressions are expressed as <mi> (in accordance with
The following MathML Units convention are adopted:
inserting a spacing invisible times operator (<mo rspace='thickmathspace'>⁢</mo>) between any numbers (<mn>) and unit expressions in MathML;
representing units in MathML as non-italic variables (<mi mathvariant='normal'>).
No whitespace is inserted between a number and a unit expression, when that unit expression wholly consists of punctuation.
1 m renders as 1 m.
1 deg_C renders as 1 °C.
However,
9 arc_degree 7 arc_minute 22 arc_second renders as 9° 7′ 22″.
The AsciiUnits in AsciiMath expression:
is converted into:
As described in
When using AsciiUnits in AsciiMath, the unit symbol referenced in the unitsml(...) expression supports the use of alternative unit symbols.
It is crucial to note that if an alternative unit symbol used in the unitsml(...) expression, the unit symbol in the MathML representation will still be the canonical unit symbol unless explicitly specified otherwise using the syntax at
An expression like 1 unitsml(mL) will be recognised as referring to the “microlitre” unit.
While the expression will be given under its canonical rendering of ml in UnitsML markup, the MathML rendering referencing that UnitsML expression will keep the notation mL.
This section provides a formal grammar for AsciiUnits syntax using Extended Backus-Naur Form (EBNF).
The grammar is derived from the Ruby implementation of AsciiUnits and the test suite at unitsml-ruby/spec/unitsml/conv/xml_spec.rb.
The EBNF notation used in this document follows these conventions:
::= defines a production rule
| represents alternatives
[ ... ] represents optional elements
{ ... } represents elements that can be repeated zero or more times
( ... ) groups elements
" ... " and ' ... ' represent literal strings
/* ... */ represents comments
Grammar breakdown: * AsciiUnits → UnitExpression → BasicUnit → UnitCode → "m"
Grammar breakdown: * AsciiUnits → UnitExpression → PrefixedUnit → PrefixCode UnitCode → "k" "g"
Grammar breakdown: * AsciiUnits → UnitExpression → CompositeUnit → MultiplicationExpression → UnitTerm "*" UnitExpression → PrefixedUnit "*" BasicUnit → "kg" "*" "m"
Grammar breakdown: * AsciiUnits → UnitExpression → CompositeUnit → DivisionExpression → UnitTerm "/" UnitExpression → BasicUnit "/" BasicUnit → "m" "/" "s"
Grammar breakdown: * AsciiUnits → UnitExpression → CompositeUnit → ExponentExpression → UnitTerm "^" Power → BasicUnit "^" Integer → "m" "^" "2"
Grammar breakdown: * AsciiUnits → UnitExpression → CompositeUnit → SqrtExpression → "sqrt(" UnitExpression ")" → "sqrt(" BasicUnit ")" → "sqrt(" "Hz" ")"
Grammar breakdown: * AsciiUnits → UnitExpression → CompositeUnit → ExponentExpression → UnitTerm "^" Power → BasicUnit "^" "(" "-" Integer ")" → "m" "^" "(" "-" "2" ")"
Grammar breakdown: * AsciiUnits → UnitExpression "," Metadata → CompositeUnit "," MetadataItem → MultiplicationExpression "," MetadataKey ":" MetadataValue → UnitTerm "*" MultiplicationExpression "," "symbol" ":" "cd cdot sr cdot m^(-2)"
Railroad diagrams provide a visual representation of the grammar rules. Below are railroad diagrams for the main components of the AsciiUnits grammar:
The EBNF grammar defined in this section has been validated against the test suite at unitsml-ruby/spec/unitsml/conv/xml_spec.rb. All test cases in the suite conform to the grammar rules.
The grammar provides a formal specification of the AsciiUnits syntax, which can be used to:
Implement parsers and generators for AsciiUnits
Validate AsciiUnits expressions
Document the AsciiUnits syntax in a precise and unambiguous way
Ensure interoperability between different implementations of AsciiUnits
Some symbols used in AsciiUnits are fundamental symbols that while exist in UnitsDB as individual entries, they are considered constant entries because of the fundamental nature of their values.
Dimensions are represented by the following symbols.
| Dimension | UnitsDB symbol | UnitsDB ID |
|---|---|---|
| Length | dim_L | NISTd1 |
| Mass | dim_M | NISTd2 |
| Time | dim_T | NISTd3 |
| Electric current | dim_I | NISTd4 |
| Thermodynamic temperature | dim_Theta | NISTd5 |
| Amount of substance | dim_N | NISTd6 |
| Luminous intensity | dim_J | NISTd7 |
| Plane angle (dimensionless) | dim_phi | NISTd9 |
unitsml(dim_I) for the dimension of electric current, 𝖨.
This table maps from NIST SP 811, Table 7.
| Name | UnitsDB symbol | UnitsDB name | UnitsDB ID |
|---|---|---|---|
| electronvolt | eV | electronvolt | NISTu240 |
| astronomical unit | ua | astronomical unit | NISTu183 |
| unified atomic mass unit | u | unified atomic mass unit | NISTu241 |
| dalton | Da | dalton | NISTu289 |
Natural units and atomic units are represented by the following symbols.
This table maps from NIST SP 811, Table 8.
| Quantity kind | UnitsDB symbol | Description | UnitsDB name | UnitsDB ID |
| speed | c | Speed of light in vacuum (n.u.) | natural unit of velocity | NISTu242 |
| action | h-bar | Planck constant divided by 2π (n.u.) | natural unit of action | NISTu243 |
| mass | m_e | electron rest mass (n.u. and a.u.) | natural unit of action | NISTu244 |
| electric charge | e | elementary charge (a.u.) | atomic unit of charge | NISTu246 |
| length | a_0 | Bohr radius (a.u.) | atomic unit of length | NISTu249 |
| energy | e_h | Hartree energy (a.u.) | atomic unit of energy | NISTu250 |
| time | h/E_h | ratio of action to energy (a.u.) | natural unit of time | NISTu248 |
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 UnitsDB’s Units database.
B is ambiguous between bel (as in decibel) and byte.
These units 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 lists ambiguous symbols and how they are disambiguated in the symbol IDs.
| Symbol | Unit + ID | Unit + ID | Unit + ID | Unit + ID | Unit + ID |
|---|---|---|---|---|---|
| ′ | minute (minute of arc): ' | foot: '_ft | minute: '_min | minute of arc: prime | foot: prime_ft |
| ″ | second (second of arc): " | second: "_s | inch: "_in | second of arc: dprime | second: dprime_s |
| ″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 |
| hp | horsepower: hp | horsepower (UK): hp_UK | horsepower, water: hp_water | horsepower, metric: hp_metric | horsepower, boiler: hp_boiler |
| 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 | ||
| inH2O | 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 | |||
| cmH2O | 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 | |||
| ftH2O | 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 | |||
| ′Hg | conventional foot of mercury: 'Hg | conventional foot of mercury: prime_Hg | |||
| ℏ | natural unit of action: h-bar | atomic unit of action: h-bar_atomic | |||
| me | 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 |
This test suite is used for:
Validating implementations of AsciiUnits parsers and generators
Ensuring compatibility between different implementations
Providing examples for users of AsciiUnits
Serving as a reference for the expected behavior of AsciiUnits
Implementers of AsciiUnits parsers and generators should ensure that their implementations can correctly process all the examples in this test suite.
This comprehensive test suite for AsciiUnits is based on the Ruby implementation’s test suite at unitsml-ruby/spec/unitsml/conv/xml_spec.rb.
The test suite includes a variety of AsciiUnits statements and their corresponding XML representations, serving as a reference for implementers and users of AsciiUnits.
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
AsciiUnits statement:
XML representation:
The following documents are referred to in the text in such a way that some or all of their content constitutes requirements of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.