SI - io.github.karols.units.SI

Type Members

type CelsiusScale = DefineAffineSpace[CelsiusZero, celsius_deg]
sealed trait CelsiusZero extends AnyRef
type KelvinScale = DefineAffineSpace[KelvinZero, kelvin]
sealed trait KelvinZero extends AnyRef
type ampere = ^[ASingleUnit[_A], P1]
type angstrom = ^[ASingleUnit[_AA], P1]
type are = ^[ASingleUnit[_a], P1]
type atmosphere = ^[ASingleUnit[~:[_a, ~:[_t, _m]]], P1]
type bar = ^[ASingleUnit[~:[_b, ~:[_a, _r]]], P1]
type bequerel = ^[ASingleUnit[_s], Negate]
type bequerel_repr = ^[ASingleUnit[~:[_B, _q]], P1]
type candela = ^[ASingleUnit[~:[_c, _d]], P1]
type celsius_deg = ^[ASingleUnit[~:[_deg, _C]], P1]
type centiliter = ^[ASingleUnit[~:[_c, _l]], P1]
type centilitre = ^[ASingleUnit[~:[_c, _l]], P1]
type centimeter = ^[ASingleUnit[~:[_c, _m]], P1]
type centimetre = ^[ASingleUnit[~:[_c, _m]], P1]
type coulomb = **[^[ASingleUnit[_s], P1], ^[ASingleUnit[_A], P1]]
type coulomb_repr = ^[ASingleUnit[_C], P1]
type day = ^[ASingleUnit[_d], P1]
type decagram = ^[ASingleUnit[~:[_d, ~:[_a, _g]]], P1]
type dekagram = ^[ASingleUnit[~:[_d, ~:[_a, _g]]], P1]
type farad = **[**[MulSingle[^[ASingleUnit[_s], P1]], ^[UnitName, Negate]], ^[UnitName, Add[Power]]]
type farad_repr = ^[ASingleUnit[_F], P1]
type gram = ^[ASingleUnit[_g], P1]
type gray = **[^[UnitName, Negate], ^[UnitName, Add[Power]]]
type gray_repr = ^[ASingleUnit[~:[_G, _y]], P1]
type hectare = ^[ASingleUnit[~:[_h, _a]], P1]
type hectoliter = ^[ASingleUnit[~:[_h, _l]], P1]
type hectolitre = ^[ASingleUnit[~:[_h, _l]], P1]
type hectopascal = ^[ASingleUnit[~:[_h, ~:[_P, _a]]], P1]
type henry = **[**[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Add[Power]]]
type henry_repr = ^[ASingleUnit[_H], P1]
type hertz = ^[ASingleUnit[_s], Negate]
type hertz_repr = ^[ASingleUnit[~:[_H, _z]], P1]
type hour = ^[ASingleUnit[_h], P1]
type joule = **[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]
type joule_repr = ^[ASingleUnit[_J], P1]
type katal = **[^[ASingleUnit[_s], Negate], ^[ASingleUnit[~:[_m, ~:[_o, _l]]], P1]]
type katal_repr = ^[ASingleUnit[~:[_k, ~:[_a, _t]]], P1]
type kelvin = ^[ASingleUnit[_K], P1]
type kilocalorie = ^[ASingleUnit[~:[_k, ~:[_c, ~:[_a, _l]]]], P1]
type kilogram = ^[ASingleUnit[~:[_k, _g]], P1]
type kilometer = ^[ASingleUnit[~:[_k, _m]], P1]
type kilometre = ^[ASingleUnit[~:[_k, _m]], P1]
type kiloohm = ^[ASingleUnit[~:[_k, _OMEGA]], P1]
type kilovolt = ^[ASingleUnit[~:[_k, _V]], P1]
type liter = ^[ASingleUnit[_l], P1]
type litre = ^[ASingleUnit[_l], P1]
type megaohm = ^[ASingleUnit[~:[_M, _OMEGA]], P1]
type meter = ^[ASingleUnit[_m], P1]
type metre = ^[ASingleUnit[_m], P1]
type microampere = ^[ASingleUnit[~:[_mu, _A]], P1]
type microhenry = ^[ASingleUnit[~:[_mu, _H]], P1]
type micrometer = ^[ASingleUnit[~:[_mu, _m]], P1]
type micrometre = ^[ASingleUnit[~:[_mu, _m]], P1]
type microohm = ^[ASingleUnit[~:[_mu, _OMEGA]], P1]
type microsecond = ^[ASingleUnit[~:[_mu, _s]], P1]
type microvolt = ^[ASingleUnit[~:[_mu, _V]], P1]
type milliampere = ^[ASingleUnit[~:[_m, _A]], P1]
type millibar = ^[ASingleUnit[~:[_m, ~:[_b, ~:[_a, _r]]]], P1]
type milligram = ^[ASingleUnit[~:[_m, _g]], P1]
type millihenry = ^[ASingleUnit[~:[_m, _H]], P1]
type milliliter = ^[ASingleUnit[~:[_m, _l]], P1]
type millilitre = ^[ASingleUnit[~:[_m, _l]], P1]
type millimeter = ^[ASingleUnit[~:[_m, _m]], P1]
type millimetre = ^[ASingleUnit[~:[_m, _m]], P1]
type milliohm = ^[ASingleUnit[~:[_m, _OMEGA]], P1]
type millisecond = ^[ASingleUnit[~:[_m, _s]], P1]
type millivolt = ^[ASingleUnit[~:[_m, _V]], P1]
type minute = ^[ASingleUnit[~:[_m, ~:[_i, _n]]], P1]
type mole = ^[ASingleUnit[~:[_m, ~:[_o, _l]]], P1]
type nanoampere = ^[ASingleUnit[~:[_n, _A]], P1]
type nanohenry = ^[ASingleUnit[~:[_n, _H]], P1]
type nanometer = ^[ASingleUnit[~:[_n, _m]], P1]
type nanometre = ^[ASingleUnit[~:[_n, _m]], P1]
type nanoohm = ^[ASingleUnit[~:[_n, _OMEGA]], P1]
type nanosecond = ^[ASingleUnit[~:[_n, _s]], P1]
type nanovolt = ^[ASingleUnit[~:[_n, _V]], P1]
type newton = **[**[^[UnitName, Negate], ^[ASingleUnit[_m], P1]], ^[ASingleUnit[~:[_k, _g]], P1]]
type newton_repr = ^[ASingleUnit[_N], P1]
type ohm = **[**[**[MulSingle[^[ASingleUnit[_s], Negate]], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Add[Power]]]
type ohm_repr = ^[ASingleUnit[_OMEGA], P1]
type pascal = **[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]
type pascal_repr = ^[ASingleUnit[~:[_P, _a]], P1]
type second = ^[ASingleUnit[_s], P1]
type siemens = **[**[MulSingle[^[ASingleUnit[_s], P1]], ^[UnitName, Negate]], ^[UnitName, Add[Power]]]
type siemens_repr = ^[ASingleUnit[_S], P1]
type sievert = **[^[UnitName, Negate], ^[UnitName, Add[Power]]]
type tesla = **[MulSingle[^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Negate]]
type tesla_repr = ^[ASingleUnit[_T], P1]
type tonne = ^[ASingleUnit[_t], P1]
type torr = ^[ASingleUnit[~:[_T, ~:[_o, ~:[_r, _r]]]], P1]
type volt = **[MulSingle[^[ASingleUnit[~:[_k, _g]], P1]], ^[ASingleUnit[_A], Negate]]
type volt_repr = ^[ASingleUnit[_V], P1]
type watt = **[**[MulSingle[^[ASingleUnit[_s], Negate]], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]
type watt_repr = ^[ASingleUnit[_W], P1]
type weber = **[MulSingle[^[ASingleUnit[~:[_k, _g]], P1]], ^[ASingleUnit[_A], Negate]]
type weber_repr = ^[ASingleUnit[_S], P1]
type week = ^[ASingleUnit[~:[_w, ~:[_e, ~:[_e, _k]]]], P1]

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
val CGS: System3[UnitName, centimetre, UnitName, gram, UnitName, second]

Centimetre-gram-second mechanical system
val LengthInCentimeters: System1[UnitName, centimetre]

A system with a single unit: centimetre, used to measure length
val LengthInCentimetres: System1[UnitName, centimetre]

A system with a single unit: centimetre, used to measure length
val LengthInKilometers: System1[UnitName, kilometre]

A system with a single unit: kilometre, used to measure length
val LengthInKilometres: System1[UnitName, kilometre]

A system with a single unit: kilometre, used to measure length
val LengthInMeters: System1[UnitName, metre]

A system with a single unit: metre, used to measure length
val LengthInMetres: System1[UnitName, metre]

A system with a single unit: metre, used to measure length
val MKS: System3[UnitName, metre, UnitName, kilogram, UnitName, second]

Standard metre-kilogram-second mechanical system
val MassInGrams: System1[UnitName, gram]

A system with a single unit: gram, used to measure mass
val MassInKilograms: System1[UnitName, kilogram]

A system with a single unit: kilogram, used to measure mass
object Short

Shorter symbols for some SI units.
val TimeInHours: System1[UnitName, hour]

A system with a single unit: hour, used to measure time
val TimeInSeconds: System1[UnitName, second]

A system with a single unit: second, used to measure time
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit val implicit__A_to_mA: BaseIntRatio[ampere, milliampere]
implicit val implicit__A_to_nA: BaseIntRatio[ampere, nanoampere]
implicit val implicit__A_to_µA: BaseIntRatio[ampere, microampere]
implicit val implicit__H_to_mH: BaseIntRatio[henry, millihenry]
implicit val implicit__H_to_nH: BaseIntRatio[henry, nanohenry]
implicit val implicit__H_to_µH: BaseIntRatio[henry, microhenry]
implicit val implicit__MΩ_to_kΩ: BaseIntRatio[megaohm, kiloohm]
implicit val implicit__MΩ_to_mΩ: BaseIntRatio[megaohm, milliohm]
implicit val implicit__MΩ_to_nΩ: BaseIntRatio[megaohm, nanoohm]
implicit val implicit__MΩ_to_µΩ: BaseIntRatio[megaohm, microohm]
implicit val implicit__MΩ_to_Ω: BaseIntRatio[megaohm, ohm]
implicit val implicit__Torr_to_Pa: BaseDoubleRatio[torr, pascal]
implicit val implicit__Torr_to_bar: BaseDoubleRatio[torr, bar]
implicit val implicit__Torr_to_hPa: BaseDoubleRatio[torr, hectopascal]
implicit val implicit__Torr_to_mbar: BaseDoubleRatio[torr, millibar]
implicit val implicit__V_to_mV: BaseIntRatio[volt, millivolt]
implicit val implicit__V_to_nV: BaseIntRatio[volt, nanovolt]
implicit val implicit__V_to_µV: BaseIntRatio[volt, microvolt]
implicit val implicit__a_to_m2: BaseIntRatio[are, ×[metre, metre]]
implicit val implicit__atm_to_Pa: BaseIntRatio[atmosphere, pascal]
implicit val implicit__atm_to_Torr: BaseIntRatio[atmosphere, torr]
implicit val implicit__atm_to_bar: BaseDoubleRatio[atmosphere, bar]
implicit val implicit__atm_to_hPa: BaseDoubleRatio[atmosphere, hectopascal]
implicit val implicit__atm_to_mbar: BaseDoubleRatio[atmosphere, millibar]
implicit val implicit__bar_to_Pa: BaseIntRatio[bar, pascal]
implicit val implicit__bar_to_hPa: BaseIntRatio[bar, hectopascal]
implicit val implicit__bar_to_mbar: BaseIntRatio[bar, millibar]
implicit val implicit__bequerel_alias: UnitAlias[bequerel, bequerel_repr]
implicit val implicit__celsiusKelvin: DoubleATwoValues[CelsiusScale, KelvinScale]
implicit val implicit__cl_to_cm3: BaseIntRatio[centilitre, cube[centimetre]]
implicit val implicit__cl_to_ml: BaseIntRatio[centilitre, millilitre]
implicit val implicit__cm_to_AA: BaseIntRatio[centimetre, angstrom]
implicit val implicit__cm_to_mm: BaseIntRatio[centimetre, millimetre]
implicit val implicit__cm_to_nm: BaseIntRatio[centimetre, nanometre]
implicit val implicit__cm_to_um: BaseIntRatio[centimetre, micrometre]
implicit val implicit__coulomb_alias: UnitAlias[coulomb, coulomb_repr]
implicit val implicit__d_to_h: BaseIntRatio[day, hour]
implicit val implicit__d_to_min: BaseIntRatio[day, minute]
implicit val implicit__d_to_ms: BaseIntRatio[day, millisecond]
implicit val implicit__d_to_ns: BaseIntRatio[day, nanosecond]
implicit val implicit__d_to_s: BaseIntRatio[day, second]
implicit val implicit__d_to_us: BaseIntRatio[day, microsecond]
implicit val implicit__dag_to_g: BaseIntRatio[decagram, gram]
implicit val implicit__dag_to_mg: BaseIntRatio[decagram, milligram]
implicit val implicit__farad_alias: UnitAlias[farad, farad_repr]
implicit val implicit__g_to_mg: BaseIntRatio[gram, milligram]
implicit val implicit__gray_alias: UnitAlias[gray, gray_repr]
implicit val implicit__hPa_to_Pa: BaseIntRatio[hectopascal, pascal]
implicit val implicit__h_to_min: BaseIntRatio[hour, minute]
implicit val implicit__h_to_ms: BaseIntRatio[hour, millisecond]
implicit val implicit__h_to_ns: BaseIntRatio[hour, nanosecond]
implicit val implicit__h_to_s: BaseIntRatio[hour, second]
implicit val implicit__h_to_us: BaseIntRatio[hour, microsecond]
implicit val implicit__ha_to_a: BaseIntRatio[hectare, are]
implicit val implicit__ha_to_m2: BaseIntRatio[hectare, ×[metre, metre]]
implicit val implicit__henry_alias: UnitAlias[henry, henry_repr]
implicit val implicit__hertz_alias: UnitAlias[hertz, hertz_repr]
implicit val implicit__hl_to_l: BaseIntRatio[hectolitre, litre]
implicit val implicit__joule_alias: UnitAlias[joule, joule_repr]
implicit val implicit__kV_to_V: BaseIntRatio[kilovolt, volt]
implicit val implicit__kV_to_mV: BaseIntRatio[kilovolt, millivolt]
implicit val implicit__kV_to_nV: BaseIntRatio[kilovolt, nanovolt]
implicit val implicit__kV_to_µV: BaseIntRatio[kilovolt, microvolt]
implicit val implicit__katal_alias: UnitAlias[katal, katal_repr]
implicit val implicit__kcal_to_J: BaseIntRatio[kilocalorie, joule]
implicit val implicit__kelvin_celsius_eq: UnitAlias[kelvin, celsius_deg]
implicit val implicit__kg_to_dag: BaseIntRatio[kilogram, decagram]
implicit val implicit__kg_to_g: BaseIntRatio[kilogram, gram]
implicit val implicit__kg_to_mg: BaseIntRatio[kilogram, milligram]
implicit val implicit__km2_to_a: BaseIntRatio[×[kilometre, kilometre], are]
implicit val implicit__km2_to_ha: BaseIntRatio[×[kilometre, kilometre], hectare]
implicit val implicit__km_to_AA: BaseIntRatio[kilometre, angstrom]
implicit val implicit__km_to_cm: BaseIntRatio[kilometre, centimetre]
implicit val implicit__km_to_m: BaseIntRatio[kilometre, metre]
implicit val implicit__km_to_mm: BaseIntRatio[kilometre, millimetre]
implicit val implicit__km_to_nm: BaseIntRatio[kilometre, nanometre]
implicit val implicit__km_to_um: BaseIntRatio[kilometre, micrometre]
implicit val implicit__kmph_to_mps: BaseDoubleRatio[Mul[Invert], Mul[Invert]]
implicit val implicit__kΩ_to_mΩ: BaseIntRatio[kiloohm, milliohm]
implicit val implicit__kΩ_to_nΩ: BaseIntRatio[kiloohm, nanoohm]
implicit val implicit__kΩ_to_µΩ: BaseIntRatio[kiloohm, microohm]
implicit val implicit__kΩ_to_Ω: BaseIntRatio[kiloohm, ohm]
implicit val implicit__l_to_cl: BaseIntRatio[litre, centilitre]
implicit val implicit__l_to_cm3: BaseIntRatio[litre, cube[centimetre]]
implicit val implicit__l_to_ml: BaseIntRatio[litre, millilitre]
implicit val implicit__m3_to_hl: BaseIntRatio[cube[metre], hectolitre]
implicit val implicit__m3_to_l: BaseIntRatio[cube[metre], litre]
implicit val implicit__mA_to_nA: BaseIntRatio[milliampere, nanoampere]
implicit val implicit__mA_to_µA: BaseIntRatio[milliampere, microampere]
implicit val implicit__mH_to_nH: BaseIntRatio[millihenry, nanohenry]
implicit val implicit__mH_to_µH: BaseIntRatio[millihenry, microhenry]
implicit val implicit__mV_to_nV: BaseIntRatio[millivolt, nanovolt]
implicit val implicit__mV_to_µV: BaseIntRatio[millivolt, microvolt]
implicit val implicit__m_to_AA: BaseIntRatio[metre, angstrom]
implicit val implicit__m_to_cm: BaseIntRatio[metre, centimetre]
implicit val implicit__m_to_mm: BaseIntRatio[metre, millimetre]
implicit val implicit__m_to_nm: BaseIntRatio[metre, nanometre]
implicit val implicit__m_to_um: BaseIntRatio[metre, micrometre]
implicit val implicit__mbar_to_Pa: BaseIntRatio[millibar, pascal]
implicit val implicit__min_to_ms: BaseIntRatio[minute, millisecond]
implicit val implicit__min_to_ns: BaseIntRatio[minute, nanosecond]
implicit val implicit__min_to_s: BaseIntRatio[minute, second]
implicit val implicit__min_to_us: BaseIntRatio[minute, microsecond]
implicit val implicit__ml_to_cm3: UnitAlias[cube[centimetre], millilitre]
implicit val implicit__mm_to_AA: BaseIntRatio[millimetre, angstrom]
implicit val implicit__mm_to_nm: BaseIntRatio[millimetre, nanometre]
implicit val implicit__mm_to_um: BaseIntRatio[millimetre, micrometre]
implicit val implicit__mps_to_cmps: BaseIntRatio[Mul[Invert], Mul[Invert]]
implicit val implicit__ms_to_ns: BaseIntRatio[millisecond, nanosecond]
implicit val implicit__ms_to_us: BaseIntRatio[millisecond, microsecond]
implicit val implicit__mΩ_to_nΩ: BaseIntRatio[milliohm, nanoohm]
implicit val implicit__mΩ_to_µΩ: BaseIntRatio[milliohm, microohm]
implicit val implicit__newton_alias: UnitAlias[newton, newton_repr]
implicit val implicit__nm_to_AA: BaseIntRatio[nanometre, angstrom]
implicit val implicit__ohm_alias: UnitAlias[ohm, ohm_repr]
implicit val implicit__pascal_alias: UnitAlias[pascal, pascal_repr]
implicit val implicit__s_to_ms: BaseIntRatio[second, millisecond]
implicit val implicit__s_to_ns: BaseIntRatio[second, nanosecond]
implicit val implicit__s_to_us: BaseIntRatio[second, microsecond]
implicit val implicit__siemens_alias: UnitAlias[siemens, siemens_repr]
implicit val implicit__t_to_dag: BaseIntRatio[tonne, decagram]
implicit val implicit__t_to_g: BaseIntRatio[tonne, gram]
implicit val implicit__t_to_kg: BaseIntRatio[tonne, kilogram]
implicit val implicit__t_to_mg: BaseIntRatio[tonne, milligram]
implicit val implicit__tesla_alias: UnitAlias[tesla, tesla_repr]
implicit val implicit__um_to_AA: BaseIntRatio[micrometre, angstrom]
implicit val implicit__um_to_nm: BaseIntRatio[micrometre, nanometre]
implicit val implicit__us_to_ns: BaseIntRatio[microsecond, nanosecond]
implicit val implicit__volt_alias: UnitAlias[volt, volt_repr]
implicit val implicit__watt_alias: UnitAlias[watt, watt_repr]
implicit val implicit__weber_alias: UnitAlias[weber, weber_repr]
implicit val implicit__week_to_d: BaseIntRatio[week, day]
implicit val implicit__week_to_h: BaseIntRatio[week, hour]
implicit val implicit__week_to_min: BaseIntRatio[week, minute]
implicit val implicit__week_to_ms: BaseIntRatio[week, millisecond]
implicit val implicit__week_to_ns: BaseIntRatio[week, nanosecond]
implicit val implicit__week_to_s: BaseIntRatio[week, second]
implicit val implicit__week_to_us: BaseIntRatio[week, microsecond]
implicit val implicit__µA_to_nA: BaseIntRatio[microampere, nanoampere]
implicit val implicit__µH_to_nH: BaseIntRatio[microhenry, nanohenry]
implicit val implicit__µV_to_nV: BaseIntRatio[microvolt, nanovolt]
implicit val implicit__µΩ_to_nΩ: BaseIntRatio[microohm, nanoohm]
implicit val implicit__Ω_to_mΩ: BaseIntRatio[ohm, milliohm]
implicit val implicit__Ω_to_nΩ: BaseIntRatio[ohm, nanoohm]
implicit val implicit__Ω_to_µΩ: BaseIntRatio[ohm, microohm]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

SI

object SI

Type Members

type CelsiusScale = DefineAffineSpace[CelsiusZero, celsius_deg]

sealed trait CelsiusZero extends AnyRef

type KelvinScale = DefineAffineSpace[KelvinZero, kelvin]

sealed trait KelvinZero extends AnyRef

type ampere = ^[ASingleUnit[_A], P1]

type angstrom = ^[ASingleUnit[_AA], P1]

type are = ^[ASingleUnit[_a], P1]

type atmosphere = ^[ASingleUnit[~:[_a, ~:[_t, _m]]], P1]

type bar = ^[ASingleUnit[~:[_b, ~:[_a, _r]]], P1]

type bequerel = ^[ASingleUnit[_s], Negate]

type bequerel_repr = ^[ASingleUnit[~:[_B, _q]], P1]

type candela = ^[ASingleUnit[~:[_c, _d]], P1]

type celsius_deg = ^[ASingleUnit[~:[_deg, _C]], P1]

type centiliter = ^[ASingleUnit[~:[_c, _l]], P1]

type centilitre = ^[ASingleUnit[~:[_c, _l]], P1]

type centimeter = ^[ASingleUnit[~:[_c, _m]], P1]

type centimetre = ^[ASingleUnit[~:[_c, _m]], P1]

type coulomb = **[^[ASingleUnit[_s], P1], ^[ASingleUnit[_A], P1]]

type coulomb_repr = ^[ASingleUnit[_C], P1]

type day = ^[ASingleUnit[_d], P1]

type decagram = ^[ASingleUnit[~:[_d, ~:[_a, _g]]], P1]

type dekagram = ^[ASingleUnit[~:[_d, ~:[_a, _g]]], P1]

type farad = **[**[MulSingle[^[ASingleUnit[_s], P1]], ^[UnitName, Negate]], ^[UnitName, Add[Power]]]

type farad_repr = ^[ASingleUnit[_F], P1]

type gram = ^[ASingleUnit[_g], P1]

type gray = **[^[UnitName, Negate], ^[UnitName, Add[Power]]]

type gray_repr = ^[ASingleUnit[~:[_G, _y]], P1]

type hectare = ^[ASingleUnit[~:[_h, _a]], P1]

type hectoliter = ^[ASingleUnit[~:[_h, _l]], P1]

type hectolitre = ^[ASingleUnit[~:[_h, _l]], P1]

type hectopascal = ^[ASingleUnit[~:[_h, ~:[_P, _a]]], P1]

type henry = **[**[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Add[Power]]]

type henry_repr = ^[ASingleUnit[_H], P1]

type hertz = ^[ASingleUnit[_s], Negate]

type hertz_repr = ^[ASingleUnit[~:[_H, _z]], P1]

type hour = ^[ASingleUnit[_h], P1]

type joule = **[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]

type joule_repr = ^[ASingleUnit[_J], P1]

type katal = **[^[ASingleUnit[_s], Negate], ^[ASingleUnit[~:[_m, ~:[_o, _l]]], P1]]

type katal_repr = ^[ASingleUnit[~:[_k, ~:[_a, _t]]], P1]

type kelvin = ^[ASingleUnit[_K], P1]

type kilocalorie = ^[ASingleUnit[~:[_k, ~:[_c, ~:[_a, _l]]]], P1]

type kilogram = ^[ASingleUnit[~:[_k, _g]], P1]

type kilometer = ^[ASingleUnit[~:[_k, _m]], P1]

type kilometre = ^[ASingleUnit[~:[_k, _m]], P1]

type kiloohm = ^[ASingleUnit[~:[_k, _OMEGA]], P1]

type kilovolt = ^[ASingleUnit[~:[_k, _V]], P1]

type liter = ^[ASingleUnit[_l], P1]

type litre = ^[ASingleUnit[_l], P1]

type megaohm = ^[ASingleUnit[~:[_M, _OMEGA]], P1]

type meter = ^[ASingleUnit[_m], P1]

type metre = ^[ASingleUnit[_m], P1]

type microampere = ^[ASingleUnit[~:[_mu, _A]], P1]

type microhenry = ^[ASingleUnit[~:[_mu, _H]], P1]

type micrometer = ^[ASingleUnit[~:[_mu, _m]], P1]

type micrometre = ^[ASingleUnit[~:[_mu, _m]], P1]

type microohm = ^[ASingleUnit[~:[_mu, _OMEGA]], P1]

type microsecond = ^[ASingleUnit[~:[_mu, _s]], P1]

type microvolt = ^[ASingleUnit[~:[_mu, _V]], P1]

type milliampere = ^[ASingleUnit[~:[_m, _A]], P1]

type millibar = ^[ASingleUnit[~:[_m, ~:[_b, ~:[_a, _r]]]], P1]

type milligram = ^[ASingleUnit[~:[_m, _g]], P1]

type millihenry = ^[ASingleUnit[~:[_m, _H]], P1]

type milliliter = ^[ASingleUnit[~:[_m, _l]], P1]

type millilitre = ^[ASingleUnit[~:[_m, _l]], P1]

type millimeter = ^[ASingleUnit[~:[_m, _m]], P1]

type millimetre = ^[ASingleUnit[~:[_m, _m]], P1]

type milliohm = ^[ASingleUnit[~:[_m, _OMEGA]], P1]

type millisecond = ^[ASingleUnit[~:[_m, _s]], P1]

type millivolt = ^[ASingleUnit[~:[_m, _V]], P1]

type minute = ^[ASingleUnit[~:[_m, ~:[_i, _n]]], P1]

type mole = ^[ASingleUnit[~:[_m, ~:[_o, _l]]], P1]

type nanoampere = ^[ASingleUnit[~:[_n, _A]], P1]

type nanohenry = ^[ASingleUnit[~:[_n, _H]], P1]

type nanometer = ^[ASingleUnit[~:[_n, _m]], P1]

type nanometre = ^[ASingleUnit[~:[_n, _m]], P1]

type nanoohm = ^[ASingleUnit[~:[_n, _OMEGA]], P1]

type farad = [[MulSingle[^[ASingleUnit[_s], P1]], ^[UnitName, Negate]], ^[UnitName, Add[Power]]]

type henry = [[**[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Add[Power]]]

type joule = [[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]

type newton = [[^[UnitName, Negate], ^[ASingleUnit[_m], P1]], ^[ASingleUnit[~:[_k, _g]], P1]]

type ohm = [[**[MulSingle[^[ASingleUnit[_s], Negate]], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]], ^[UnitName, Add[Power]]]

type pascal = [[^[UnitName, Negate], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]

type siemens = [[MulSingle[^[ASingleUnit[_s], P1]], ^[UnitName, Negate]], ^[UnitName, Add[Power]]]

type watt = [[MulSingle[^[ASingleUnit[_s], Negate]], ^[UnitName, Add[Power]]], ^[ASingleUnit[~:[_k, _g]], P1]]