Options
All
  • Public
  • Public/Protected
  • All
Menu

Module Units

Representation and manipulation of physical units.

These are based on SI, and in particular the (Guide for the Use of the International System of Units (SI))https://physics.nist.gov/cuu/pdf/sp811.pdf(https://physics.nist.gov/cuu/pdf/sp811.pdf]) However, this does not try to be complete, and extends the set of base units somewhat to aid clarity (for example, 'cycles/revolutions') while preserving semantics and standardized presentation. Having units that map to SI '1' is not very helpful sometimes.

See the Units.Units namespace for definitions of individual units.

Index

Namespaces

Enumerations

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

CompleteTerms

CompleteTerms<A>: {}

Take a partial set of UnitTerms, and fills in the missing exponents with 0.

Type parameters

Type declaration

Divide

Divide<A, B>: A extends Unit<infer TA> ? B extends Unit<infer TB> ? Unit<DivideTerms<TA, TB>> : never : never

Divide two Unit types, A/B (by subtracting the exponents).

Type parameters

DivideTerms

DivideTerms<A, B>: {}

Divide two UnitTerms, A/B

Type parameters

Type declaration

Exponent

Exponent: -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Our supported exponents. A finite list of exponents allows TypeScript to automatically type exponents as numeric literal types.

InvertTerms

InvertTerms<A>: {}

Invert a UnitTerms (by negating the exponents).

Type parameters

Type declaration

Multiply

Multiply<A, B>: A extends IUnitBase<infer TA> ? B extends IUnitBase<infer TB> ? Unit<MultiplyTerms<TA, TB>> : never : never

Multiply two Unit types (by adding the exponents).

Type parameters

MultiplyTerms

MultiplyTerms<A, B>: {}

Multiply two UnitTerms (by adding the exponents.)

Type parameters

Type declaration

PUnitTerms

PUnitTerms: {}

An object of primitive UNIT: Exponent pairs that uniquely describes each type.

Type declaration

PrefixExponent

PrefixExponent: 24 | 21 | 18 | 15 | 12 | 9 | 6 | 3 | 2 | 1 | -1 | -2 | -3 | -6 | -9 | -12 | -15 | -18 | -21 | -24

PrefixName

PrefixName: "yotta" | "zetta" | "exa" | "peta" | "tera" | "giga" | "mega" | "kilo" | "hecto" | "deka" | "deci" | "centi" | "milli" | "micro" | "nano" | "pico" | "fempto" | "atto" | "zepto" | "yocto"

PrefixSymbol

PrefixSymbol: "Y" | "Z" | "E" | "P" | "T" | "G" | "M" | "k" | "h" | "da" | "d" | "c" | "m" | "μ" | "u" | "n" | "p" | "f" | "a" | "z" | "y"

PrimitiveMap

PrimitiveMap: {}

Type of our PRIMITIVE_MAP map. This provides one key/value entry for each primitive, indexed by the UNIT enum.

Type declaration

TermsOfUnit

TermsOfUnit<U>: U extends Unit<infer T> ? CompleteTerms<T> : never

Type parameters

TermsOfUnitBase

TermsOfUnitBase<U>: U extends IUnitBase<infer T> ? T : never

Type parameters

UnitTerms

UnitTerms: {}

An object with keys being the name of Primitive types and the values being exponents. All values are required; supply zero for values not supplied.

See PUnitTerms for a partial set where types can be left undefined.

Type declaration

Variables

Const PRIMITIVE_MAP

PRIMITIVE_MAP: Readonly<PrimitiveMap> = (() => {const val: PrimitiveMap = {} as PrimitiveMap;const defPrimitive = (u: Primitive, name: string, symbol: string, varName?: string,attributes: UnitAttributes = {}) => {const primitive = new PrimitiveUnit(u, name, symbol, varName, attributes);(val as any)[u] = primitive;primitive.names.push(u);return primitive;}defPrimitive(Primitive.time, 'second', 's', 't', {si_base: true});defPrimitive(Primitive.mass, 'kilogram', 'kg', 'm',{si_base: true, scale: 1000});defPrimitive(Primitive.length, 'meter', 'm', 'l', {si_base: true});defPrimitive(Primitive.amount, 'mole', 'mol', 'n', {si_base: true});defPrimitive(Primitive.cycles, 'cycle', 'cycle', 'c');defPrimitive(Primitive.angle, 'radian', 'rad', '𝜃');defPrimitive(Primitive.solidAngle, 'steridian', 'sr', undefined);defPrimitive(Primitive.current, 'ampere', 'A', 'A', {si_base: true});defPrimitive(Primitive.temperature, 'kelvin', 'K', 'T',{absolute: true, si_base: true});defPrimitive(Primitive.candela, 'candela', 'cd', 'c', {si_base: true})return val as PrimitiveMap;})()

A map from primitive name to its Unit instance.

Const TeX

TeX: raw = String.raw

String literal parser for LaTeX literals (avoids the need for quoting backslash).

Const primitiveKeys

primitiveKeys: Primitive[] = Object.keys(Primitive) as Primitive[]

Functions

Const defineAlias

  • defineAlias<T>(name: string, symbol: string | undefined, attributes: AliasAttributes, si: Unit<T>, scale: number, offset?: number, ...names: string[]): Unit<T> & Alias

  • Define a unit alias, which can convert to/from a corresponding standard unprefixed SI unit.

    Type parameters

    Parameters

    • name: string
    • symbol: string | undefined
    • attributes: AliasAttributes
    • si: Unit<T>
    • scale: number
    • Default value offset: number = 0
    • Rest ...names: string[]

    Returns Unit<T> & Alias

Const defineUnit

  • Define a derived type.

    The numbers in the keys are exponents for primitive types. They are taken as type literals,

    This ensures, for example, that the types of U.velocity and U.acceleration are distinct.

    const U.velocity     = defineUnit({distance: 1, time: -1});
const U.acceleration = defineUnit({distance: 1, time: -2});

    Results in types of:

    type U.velocity     = Unit<{distance: 1, time: -1}>
type U.acceleration = Unit<{distance: 1, time: -2}>

    Type parameters

    Parameters

    • key: T

      The key defining the type composition

    • Default value attributes: UnitAttributes = {}

      Additional attributes describing the type.

    • Rest ...names: string[]

      Additional names to use for this type, e.g. newton.

    Returns Unit<CompleteTerms<T>>

Const getUnit

  • getUnit(name: string, siOnly?: boolean): Unit<{}>

  • Get a unit by name.

    To process a # + unit into standard unprefixed SI, do:

    const [siVal, siUnit] = getUnit(unitName).toSI(val);

    To just get the standard SI unit, do:

    const siUnit = getUnit(unitName).si;

    Parameters

    • name: string
    • Default value siOnly: boolean = false

      if true, only unscaled SI units are returned.

    Returns Unit<{}>

Const isUnit

  • isUnit(u: any): u is Unit

Const makeLookupKey

Const orderUnits

Generated using TypeDoc