Units

This document outlines the XML representation of unit definitions, and describes the algorithms necessary to perform unit conversions in an interoperable manner. The XML representation is modelled using an annotated XML Schema:

Motivation and design goal

The representation of units described in this document, is designed with the following goals in mind:

• Most known physical units must be representable using the model.

• Unit presentations must be compact and easy to read, both for humans and machines.

• Machines must be able to perform unit conversions between compatible units based on the definitions made.

• The representation must be extensible. New units and unit systems must be able to be added.

• It must be possible to communicate using units outside of the scope of the set of units defined. In such cases, unit conversion will not be possble.

• Unit conversions must support linear and non-linear conversions.

• The unit conversion must be easily reversible.

Conceptual model

The XML representation of Units and conversion rules used by the Neuro-Foundation IoT interfaces is based on the following abstraction:

A Unit Category represents a set of units that are compatible in the sense they can be used to represent the same physical quantity and can be converted between each other. Each Unit Category defines exactly one Reference Unit. This should be the SI unit, if applicable, or contain a derivation from SI units, or similar well-known unit if SI units are not available for the corresponding physical quantity. If a derivation does not exist, it is assumed that the reference unit is a base unit. The name of a unit category should be a human-readable string that describes the physical quantity represented by the units. It is not used in unit conversion, communication, or user interfaces. It is available only for documentation purposes.

After the reference unit, the Unit Category can define any number of additional Units. There are two types: The regular Unit and the Compound Unit. Each unit is referenced to by its name, which should correspond to the short-hand form used when expressing physical quantities, for example m for meters, g for grams, s for seconds, etc.

Normal Unit objects define a set of Reverse Polish Notation Operations that converts a value expressed using the unit, to the corresponding value expressed using the reference unit associated with the unit category. The Reverse Polish Notation used in the conversion definition allows us to define the conversion without having to implement a specific expression parser. It also permits easy-to-implement algorithms both for converting a unit to the reference unit, but also the reverse, convert a reference unit to the specific unit.

Note: Any unit definition lacking operations defined, is assumed to be equivalent to the reference unit for that unit category.

Compund units on the other hand, define only a set of implicit Unit Factors. Each unit factor defines a unit, an exponent, and a factor. The compound unit is the product of the factor and the referenced units raised to the corresponding exponent. Unit conversion is performed by converting the individual factors. By looking up each of the unit factors, each compound unit can be reduced to a product of a factor and a set of base units, raised to a corresponding exponent.

Conversion Operation

Evaluating the RPN operations top-down converts a floating-point number expressed using the unit, to a floating-point number expressed using the reference unit. The operations are listed using Reverse Polish Notation, where numbers are pushed onto a stack, and operations pop the required number of operands from the stack, perform the operation, and push the result back onto the stack. Before the operation, the value being converted from is pushed as the first and only number on the stack. After the operations, the top-most value on the stack (which should be the only value on the stack) is the conversion result.

Evaluating the RPN operations bottom-up converts a floating-point number expressed using the reference unit, to a floating-point number expressed using the specific unit. But instead of pushing numbers to the stack, binary operations are pushed on the stack, and number values pop operations from the stack and execute the inverse operation. Unary operations are executed in its inverse form directly on the top-most value on the stack, replacing the top-most value with the result.

Note: Unit conversion defined by the operations are based on the values without prefixes. If values are expressed using prefixes, such as k for kilo, M for mega, etc., the prefix needs to be applied before conversion, and a suitable prefix selected after conversion. A similar consideration needs to be taken into account for the number of significant digits in the value, if expressed as a human-readable string.

Operations

The following operations are defined in the XML schema, and can be used in the unit conversions. The description describes the operator when executed from top to bottom. The elements on the stack are referred to as S_-1 as the topmost element (before the execution of an operator), and S_-2 as the element below the topmost element (before the execution of an operator).

Inverted Operations

The inverted operations are the inverse of the above operations, and are used to convert a value from the reference unit to the specific unit. The inverted operations are evaluated bottom-up, and are evaluated as follows. Note that binary operations push their inverted operation on the stack. A number checks the topmost element on the stack. If it is a binary operator is on the stack, that operator is popped and executed on are pushed on the stack, while numbers pop the operations from the stack and execute them. Unary operations are executed directly.

Example

Consider the unit category definition for Temperature:

<Category name="Temperature">
	<ReferenceUnit name="K"/>
	<Unit name="°C">
		<Number>273.15</Number>
		<Add/>
	</Unit>
	<Unit name="°F">
		<Number>32</Number>
		<Sub/>
		<Number>5</Number>
		<Mul/>
		<Number>9</Number>
		<Div/>
		<Number>273.15</Number>
		<Add/>
	</Unit>
</Category>

We want to convert 50° F to °C. We follow the operations defined for the °F unit to convert the value to the reference unit, which is K:

So, we have calculated that 50° F = 283.15 K. Now we need to do the reverse operation to convert the Kelvin value to °C, remembering that binary operations have their inverted operation pushed to the stack and numbers pop the operations.

The result is 10° C. If we attempt to convert 10° C back to °F, we use the operations defined for the Celcius unit:

So, 10° C = 283.15 K. We do the inverse calculation defined for the Fahrenheit unit, to convert this value to Fahrenheit:

And the result is 50° F.

Base Units

Base units are the fundamental units of measurement in the International System of Units (SI).

Derived Units

Units that can be derived from base units will have their reference unit expressed as a product of powers of base units. For example, Voltage (V) can be expressed as 1000⋅g⋅m²⋅s^-3⋅A^-1. Unit artithmetic can be performed on such base units, if all units involved are first reduced to expressions using the base units.

Compound Units

Compund units are expressed as a products of their components. A Wh is the product W⋅h for example. A compound unit can be reduced to the product of its components, each of which can be reduced to the corresponding base units, for unit artithmetics.

Unit Definitions

The units definition file Units.xml contains the following unit definitions.

Current

Reference Unit: A

Dimensionless

Reference Unit: 1

Length

Reference Unit: m

Mass

Reference Unit: g

Temperature

Reference Unit: K

Time

Reference Unit: s

Capacitance

Reference Unit: F
Derivation: 1e-3⋅m^-2⋅g^-1⋅s⁴⋅A²

Charge

Reference Unit: C
Derivation: s⋅A

Energy

Reference Unit: J
Derivation: 1000⋅g⋅m²⋅s^-2

Force

Reference Unit: N
Derivation: 1000⋅g⋅m⋅s^-2

Frequency

Reference Unit: Hz
Derivation: s^-1

Power

Reference Unit: W
Derivation: 1000⋅g⋅m²⋅s^-3

Pressure

Reference Unit: Pa
Derivation: 1000⋅g⋅m^-1⋅s^-2

Resistance

Reference Unit: Ω
Derivation: 1000⋅m²⋅g⋅s^-3⋅A^-2

Speed

Reference Unit: mps
Derivation: m⋅s^-1

Voltage

Reference Unit: V
Derivation: 1000⋅g⋅m²⋅s^-3⋅A^-1

Volume

Reference Unit: m³
Derivation: m³