[#mp_units]
= mp&lowbar;units
:mrdocs:

The Measurement Library

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/utility.adoc[`utility`] 
| Public authoring vocabulary shared by the library&apos;s own customization points and by higher&hyphen;level tools&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/absolute_point_origin.adoc[`absolute&lowbar;point&lowbar;origin`] 
| A point origin located at the zero point of a quantity specification
| xref:mp_units/base_dimension.adoc[`base&lowbar;dimension`] 
| A dimension of a base quantity
| xref:mp_units/basic_fixed_string-08.adoc[`basic&lowbar;fixed&lowbar;string`] 
| A compile&hyphen;time fixed string
| xref:mp_units/check_in_range.adoc[`check&lowbar;in&lowbar;range`] 
| Policy that checks the value is within &lsqb;min, max&rsqb;and reports violations&period;
| xref:mp_units/check_non_negative.adoc[`check&lowbar;non&lowbar;negative`] 
| Policy that checks the value is ≥ 0 and reports violations&period;
| xref:mp_units/clamp_non_negative.adoc[`clamp&lowbar;non&lowbar;negative`] 
| Policy that clamps the value to &lsqb;0, ∞)&period;&rsqb;
| xref:mp_units/clamp_to_range.adoc[`clamp&lowbar;to&lowbar;range`] 
| Policy that clamps the value to &lsqb;min, max&rsqb;&period;
| xref:mp_units/common_unit.adoc[`common&lowbar;unit`] 
| Measurement unit for an accumulation of two quantities of different units
| xref:mp_units/constraint_violation_handler.adoc[`constraint&lowbar;violation&lowbar;handler`] 
| Customization point for handling domain constraint violations&period;
| xref:mp_units/derived_dimension.adoc[`derived&lowbar;dimension`] 
| A dimension of a derived quantity
| xref:mp_units/derived_quantity_spec.adoc[`derived&lowbar;quantity&lowbar;spec`] 
| A specification of a derived quantity
| xref:mp_units/derived_unit.adoc[`derived&lowbar;unit`] 
| Measurement unit for a derived quantity
| xref:mp_units/dimension_one-063.adoc[`dimension&lowbar;one`] 
| Dimension one
| xref:mp_units/dimension_symbol_formatting.adoc[`dimension&lowbar;symbol&lowbar;formatting`] 
| Formatting options for `dimension&lowbar;symbol` and `dimension&lowbar;symbol&lowbar;to`&period;
| xref:mp_units/dimensionless-0f.adoc[`dimensionless`] 
| Quantity of dimension one
| xref:mp_units/is_kind-06.adoc[`is&lowbar;kind`] 
| Tag property marking a `quantity&lowbar;spec` as the start of a new hierarchy tree of a kind
| xref:mp_units/kind_of_-00.adoc[`kind&lowbar;of&lowbar;`] 
| The type of a quantity kind for the quantity specification `Q`
| xref:mp_units/mag_constant.adoc[`mag&lowbar;constant`] 
| A named Magnitude constant identified by its symbol and, where supported, its value
| xref:mp_units/named_constant-03.adoc[`named&lowbar;constant`] 
| A constant defined in terms of a unit
| xref:mp_units/named_unit-0ec.adoc[`named&lowbar;unit`] 
| A named unit
| xref:mp_units/natural_point_origin_.adoc[`natural&lowbar;point&lowbar;origin&lowbar;`] 
| Implementation type of `natural&lowbar;point&lowbar;origin`
| xref:mp_units/non_negative-05.adoc[`non&lowbar;negative`] 
| Tag property marking a `quantity&lowbar;spec` as never holding a negative value
| xref:mp_units/one-0f.adoc[`one`] 
| Unit one
| xref:mp_units/parts_per_million-0f.adoc[`parts&lowbar;per&lowbar;million`] 
| The &quot;ppm&quot; (parts per million) unit, equal to 1&sol;1,000,000
| xref:mp_units/per.adoc[`per`] 
| Type list type storing the list of components with negative exponents
| xref:mp_units/per_mille-01.adoc[`per&lowbar;mille`] 
| The &quot;‰&quot; (per mille) unit, equal to 1&sol;1000
| xref:mp_units/percent-02.adoc[`percent`] 
| The &quot;%&quot; (percent) unit, equal to 1&sol;100
| xref:mp_units/pi-0c.adoc[`pi`] 
| The mathematical constant π, exposed as a dimensionless named constant
| xref:mp_units/pi_c-0b.adoc[`pi&lowbar;c`] 
| A convenient Magnitude constant for pi, which we can manipulate like a regular number&period;
| xref:mp_units/possibly_negative-09.adoc[`possibly&lowbar;negative`] 
| Tag property canceling an inherited `non&lowbar;negative` for a `quantity&lowbar;spec`
| xref:mp_units/power.adoc[`power`] 
| Type container for exponents with ratio different than `1`
| xref:mp_units/prefixed_unit.adoc[`prefixed&lowbar;unit`] 
| A prefixed unit
| xref:mp_units/quantity-01.adoc[`quantity`] 
| A quantity
| xref:mp_units/quantity_character.adoc[`quantity&lowbar;character`] 
| Quantity character
| xref:mp_units/quantity_like_traits.adoc[`quantity&lowbar;like&lowbar;traits`] 
| Provides support for external quantity&hyphen;like types
| xref:mp_units/quantity_point-08.adoc[`quantity&lowbar;point`] 
| A quantity point
| xref:mp_units/quantity_point_like_traits.adoc[`quantity&lowbar;point&lowbar;like&lowbar;traits`] 
| Provides support for external quantity point&hyphen;like types
| xref:mp_units/quantity_spec-09.adoc[`quantity&lowbar;spec`] 
| A specification of a quantity used to define its kind, dimension, and character
| xref:mp_units/reference-0b2.adoc[`reference`] 
| Quantity reference type
| xref:mp_units/reflect_in_range.adoc[`reflect&lowbar;in&lowbar;range`] 
| Policy that reflects (folds) the value at both boundaries&period;
| xref:mp_units/relative_point_origin.adoc[`relative&lowbar;point&lowbar;origin`] 
| A point origin defined relative to another quantity point
| xref:mp_units/relative_standard_uncertainty.adoc[`relative&lowbar;standard&lowbar;uncertainty`] 
| Relative standard uncertainty of a measured constant
| xref:mp_units/representation_canonical_type-0b.adoc[`representation&lowbar;canonical&lowbar;type`] 
| Maps a representation value type to the concrete type a quantity should store&period;
| xref:mp_units/representation_underlying_type-03a.adoc[`representation&lowbar;underlying&lowbar;type`] 
| Describes the underlying arithmetic&sol;element type of a representation type&period;
| xref:mp_units/representation_values.adoc[`representation&lowbar;values`] 
| A type trait that defines zero, one, min, and max for a representation type
| xref:mp_units/rounded_down_t.adoc[`rounded&lowbar;down&lowbar;t`] 
| Tag type for the `rounded&lowbar;down` rounding policy
| xref:mp_units/rounded_t.adoc[`rounded&lowbar;t`] 
| Tag type for the `rounded` rounding policy
| xref:mp_units/rounded_up_t.adoc[`rounded&lowbar;up&lowbar;t`] 
| Tag type for the `rounded&lowbar;up` rounding policy
| xref:mp_units/scaled_unit.adoc[`scaled&lowbar;unit`] 
| Unit being a scaled version of another unit
| xref:mp_units/standard_uncertainty.adoc[`standard&lowbar;uncertainty`] 
| Absolute standard uncertainty of a measured constant
| xref:mp_units/symbol_text-032.adoc[`symbol&lowbar;text`] 
| A symbol text representation
| xref:mp_units/truncated_t.adoc[`truncated&lowbar;t`] 
| Tag type for the `truncated` rounding policy
| xref:mp_units/unit_symbol_formatting.adoc[`unit&lowbar;symbol&lowbar;formatting`] 
| Specifies the options used to format a unit symbol
| xref:mp_units/vector_axes.adoc[`vector&lowbar;axes`] 
| Ordered list of the 1D&hyphen;vector component axes a vector quantity decomposes into
| xref:mp_units/vector_components.adoc[`vector&lowbar;components`] 
| Opts a vector quantity into decomposition into named 1D&hyphen;vector components
| xref:mp_units/wrap_to_range.adoc[`wrap&lowbar;to&lowbar;range`] 
| Policy that wraps the value into the half&hyphen;open range &lsqb;min, max)&period;&rsqb;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/conditional.adoc[`conditional`] 
| Alias for `T` if `B` is `true`, otherwise `F` (equivalent to `std&colon;&colon;conditional&lowbar;t&lt;B, T, F&gt;`)
| xref:mp_units/expr_type.adoc[`expr&lowbar;type`] 
| The underlying symbolic expression factor type, unwrapping `power` if present
| xref:mp_units/fixed_string.adoc[`fixed&lowbar;string`] 
| `basic&lowbar;fixed&lowbar;string` specialized for `char`
| xref:mp_units/fixed_u16string.adoc[`fixed&lowbar;u16string`] 
| `basic&lowbar;fixed&lowbar;string` specialized for `char16&lowbar;t`
| xref:mp_units/fixed_u32string.adoc[`fixed&lowbar;u32string`] 
| `basic&lowbar;fixed&lowbar;string` specialized for `char32&lowbar;t`
| xref:mp_units/fixed_u8string.adoc[`fixed&lowbar;u8string`] 
| `basic&lowbar;fixed&lowbar;string` specialized for `char8&lowbar;t`
| xref:mp_units/fixed_wstring.adoc[`fixed&lowbar;wstring`] 
| `basic&lowbar;fixed&lowbar;string` specialized for `wchar&lowbar;t`
| xref:mp_units/quantity_values.adoc[`quantity&lowbar;values`]  [.small]#[deprecated]#
| Deprecated alias for `representation&lowbar;values`&period;
| xref:mp_units/rep_for.adoc[`rep&lowbar;for`] 
| Public alias that yields the representation type of a quantity&hyphen;like type&period;
| xref:mp_units/representation_canonical_type_t.adoc[`representation&lowbar;canonical&lowbar;type&lowbar;t`] 
| Convenience alias for `representation&lowbar;canonical&lowbar;type&lt;T&gt;&colon;&colon;type`&period;
| xref:mp_units/representation_underlying_type_t.adoc[`representation&lowbar;underlying&lowbar;type&lowbar;t`] 
| Convenience alias for `representation&lowbar;underlying&lowbar;type&lt;T&gt;&colon;&colon;type`&period;
| xref:mp_units/text_encoding.adoc[`text&lowbar;encoding`]  [.small]#[deprecated]#
| Deprecated alias for `character&lowbar;set`
| xref:mp_units/zeroth_point_origin_.adoc[`zeroth&lowbar;point&lowbar;origin&lowbar;`]  [.small]#[deprecated]#
| Deprecated alias for `natural&lowbar;point&lowbar;origin&lowbar;`
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/character_set.adoc[`character&lowbar;set`] 
| Character set used to render a `symbol&lowbar;text`
| xref:mp_units/quantity_character_legacy.adoc[`quantity&lowbar;character&lowbar;legacy`]  [.small]#[deprecated]#
| The pre&hyphen;2&period;6&period;0 flat quantity character enumeration
| xref:mp_units/quantity_field.adoc[`quantity&lowbar;field`] 
| The numeric field axis of a quantity&apos;s character
| xref:mp_units/quantity_tensor_order.adoc[`quantity&lowbar;tensor&lowbar;order`] 
| The tensor order axis of a quantity&apos;s character
| xref:mp_units/unit_symbol_separator.adoc[`unit&lowbar;symbol&lowbar;separator`] 
| Specifies the separator placed between the symbols of a unit symbol&apos;s factors
| xref:mp_units/unit_symbol_solidus.adoc[`unit&lowbar;symbol&lowbar;solidus`] 
| Specifies how the solidus (`&sol;`) is used when formatting a unit symbol&apos;s denominator
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/abs.adoc[`abs`] 
| Computes the absolute value of a quantity
| xref:mp_units/absolute.adoc[`absolute`] 
| Constructs a `quantity&lowbar;point` of reference `R` from a raw representation value
| xref:mp_units/castable.adoc[`castable`] 
| Checks whether a quantity of quantity spec `From` can be cast to quantity spec `To`
| xref:mp_units/cbrt-07.adoc[`cbrt`] 
| `cbrt` overloads
| xref:mp_units/ceil-09.adoc[`ceil`] 
| `ceil` overloads
| xref:mp_units/contains-01b.adoc[`contains`] 
| `contains` overloads
| xref:mp_units/default_point_origin.adoc[`default&lowbar;point&lowbar;origin`] 
| Returns the default point origin for a reference
| xref:mp_units/delta.adoc[`delta`] 
| Constructs a `quantity` of reference `R` from a raw representation value
| xref:mp_units/dimension_symbol.adoc[`dimension&lowbar;symbol`] 
| Returns the textual symbol of a dimension as a `std&colon;&colon;basic&lowbar;string&lowbar;view`&period;
| xref:mp_units/dimension_symbol_to.adoc[`dimension&lowbar;symbol&lowbar;to`] 
| Writes the textual symbol of a dimension to an output iterator&period;
| xref:mp_units/epsilon.adoc[`epsilon`]  [.small]#[deprecated]#
| Returns the epsilon of the quantity
| xref:mp_units/exp.adoc[`exp`] 
| Computes Euler&apos;s raised to the given power
| xref:mp_units/explicitly_convertible.adoc[`explicitly&lowbar;convertible`] 
| Checks whether a quantity of quantity spec `From` can be explicitly converted to quantity spec `To`
| xref:mp_units/floor-04.adoc[`floor`] 
| `floor` overloads
| xref:mp_units/fma-0c.adoc[`fma`] 
| `fma` overloads
| xref:mp_units/fmod.adoc[`fmod`] 
| Computes the floating&hyphen;point remainder of the division operation x &sol; y&period;
| xref:mp_units/get-0a.adoc[`get`] 
| `get` overloads
| xref:mp_units/get_canonical_unit.adoc[`get&lowbar;canonical&lowbar;unit`] 
| Computes the canonical form of a unit
| xref:mp_units/get_common_quantity_spec-08.adoc[`get&lowbar;common&lowbar;quantity&lowbar;spec`] 
| `get&lowbar;common&lowbar;quantity&lowbar;spec` overloads
| xref:mp_units/get_common_reference.adoc[`get&lowbar;common&lowbar;reference`] 
| Returns the common unit of two or more units usable as a reference
| xref:mp_units/get_common_unit-08f.adoc[`get&lowbar;common&lowbar;unit`] 
| `get&lowbar;common&lowbar;unit` overloads
| xref:mp_units/get_kind.adoc[`get&lowbar;kind`] 
| Returns the kind of a quantity specification
| xref:mp_units/get_quantity_spec-03.adoc[`get&lowbar;quantity&lowbar;spec`] 
| `get&lowbar;quantity&lowbar;spec` overloads
| xref:mp_units/get_relative_standard_uncertainty.adoc[`get&lowbar;relative&lowbar;standard&lowbar;uncertainty`] 
| Returns the relative standard uncertainty of a measured constant
| xref:mp_units/get_standard_uncertainty.adoc[`get&lowbar;standard&lowbar;uncertainty`] 
| Returns the standard uncertainty of a measured constant
| xref:mp_units/get_unit.adoc[`get&lowbar;unit`] 
| Returns the unit of a reference
| xref:mp_units/hypot-00.adoc[`hypot`] 
| `hypot` overloads
| xref:mp_units/implicitly_convertible.adoc[`implicitly&lowbar;convertible`] 
| Checks whether a quantity of quantity spec `From` can be implicitly converted to quantity spec `To`
| xref:mp_units/interconvertible.adoc[`interconvertible`] 
| Checks whether two quantity specifications are convertible to each other in both directions
| xref:mp_units/inverse-0e.adoc[`inverse`] 
| `inverse` overloads
| xref:mp_units/is_eq_zero.adoc[`is&lowbar;eq&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares equal to `T&colon;&colon;zero()`
| xref:mp_units/is_gt_zero.adoc[`is&lowbar;gt&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares greater than `T&colon;&colon;zero()`
| xref:mp_units/is_gteq_zero.adoc[`is&lowbar;gteq&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares greater than or equal to `T&colon;&colon;zero()`
| xref:mp_units/is_integral_scaling.adoc[`is&lowbar;integral&lowbar;scaling`] 
| Returns `true` if the scaling factor from `from` to `to` is an exact positive integer&period;
| xref:mp_units/is_lt_zero.adoc[`is&lowbar;lt&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares less than `T&colon;&colon;zero()`
| xref:mp_units/is_lteq_zero.adoc[`is&lowbar;lteq&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares less than or equal to `T&colon;&colon;zero()`
| xref:mp_units/is_neq_zero.adoc[`is&lowbar;neq&lowbar;zero`]  [.small]#[deprecated]#
| Checks whether `v` compares not equal to `T&colon;&colon;zero()`
| xref:mp_units/is_non_negative.adoc[`is&lowbar;non&lowbar;negative`] 
| Checks whether a quantity specification is tagged as non&hyphen;negative
| xref:mp_units/isfinite-01.adoc[`isfinite`] 
| `isfinite` overloads
| xref:mp_units/isinf-0c.adoc[`isinf`] 
| `isinf` overloads
| xref:mp_units/isnan-08.adoc[`isnan`] 
| `isnan` overloads
| xref:mp_units/lerp.adoc[`lerp`] 
| Linear interpolation or extrapolation
| xref:mp_units/midpoint.adoc[`midpoint`] 
| Computes the midpoint of two points
| xref:mp_units/operator_star-00.adoc[`operator&ast;`] 
| Multiplication operators
| xref:mp_units/operator_slash-0a.adoc[`operator&sol;`] 
| Division operators
| xref:mp_units/point.adoc[`point`] 
| Constructs a `quantity&lowbar;point` of reference `R` from a raw representation value
| xref:mp_units/pow-00.adoc[`pow`] 
| `pow` overloads
| xref:mp_units/quantity_cast-0f.adoc[`quantity&lowbar;cast`] 
| `quantity&lowbar;cast` overloads
| xref:mp_units/remainder.adoc[`remainder`] 
| Computes the IEEE remainder of the floating point division operation x &sol; y&period;
| xref:mp_units/round-01.adoc[`round`] 
| `round` overloads
| xref:mp_units/scale-05.adoc[`scale`] 
| `scale` overloads
| xref:mp_units/sqrt-0c.adoc[`sqrt`] 
| `sqrt` overloads
| xref:mp_units/unit_symbol.adoc[`unit&lowbar;symbol`] 
| Returns the textual symbol of a unit
| xref:mp_units/unit_symbol_to.adoc[`unit&lowbar;symbol&lowbar;to`] 
| Writes the textual symbol of a unit to an output iterator
| xref:mp_units/value_cast-03d.adoc[`value&lowbar;cast`] 
| `value&lowbar;cast` overloads
| xref:mp_units/operator_lshift.adoc[`operator&lt;&lt;`] 
| Streams the textual symbol of a dimension to a `std&colon;&colon;basic&lowbar;ostream`&period;
| xref:mp_units/operator_eq-0a.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:mp_units/operator_3way.adoc[`operator&lt;&equals;&gt;`] 
| Compares two quantity characters lexicographically on (order, field)
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/dimension_one-060.adoc[`dimension&lowbar;one`] 
| The unique instance of the dimension one&period;
| xref:mp_units/dimensionless-03.adoc[`dimensionless`] 
| Quantity of dimension one
| xref:mp_units/disable_representation-091.adoc[`disable&lowbar;representation`] 
| A specializable opt&hyphen;out&colon; when `true`, `T` is not accepted as a quantity representation&period;
| xref:mp_units/disable_representation-09a.adoc[`disable&lowbar;representation`] 
| Opts `bool` out of being a valid quantity representation&period;
| xref:mp_units/disable_representation-05.adoc[`disable&lowbar;representation`] 
| Opts stateless symbolic&hyphen;constant tag types out of being a valid quantity representation&period;
| xref:mp_units/frame_projection.adoc[`frame&lowbar;projection`] 
| User&hyphen;specializable variable template for runtime coordinate frame transformations&period;
| xref:mp_units/imag.adoc[`imag`] 
| Customization point object returning the imaginary part of a complex&hyphen;like value&period;
| xref:mp_units/implicitly_scalable.adoc[`implicitly&lowbar;scalable`] 
| Controls whether conversion from `quantity&lt;FromUnit, FromRep&gt;` to `quantity&lt;ToUnit, ToRep&gt;` is implicit or explicit&period;
| xref:mp_units/is_complex.adoc[`is&lowbar;complex`]  [.small]#[deprecated]#
| Deprecated, no longer necessary&semi; kept only for backward compatibility&period;
| xref:mp_units/is_derived_from_specialization_of.adoc[`is&lowbar;derived&lowbar;from&lowbar;specialization&lowbar;of`] 
| Whether `T` is derived from some specialization of the class template `Type`, which takes type parameters
| xref:mp_units/is_derived_from_specialization_of_v.adoc[`is&lowbar;derived&lowbar;from&lowbar;specialization&lowbar;of&lowbar;v`] 
| Whether `T` is derived from some specialization of the class template `Type`, which takes non&hyphen;type (`auto`) parameters
| xref:mp_units/is_kind-0b.adoc[`is&lowbar;kind`] 
| The unique instance of the `is&lowbar;kind` tag property&period;
| xref:mp_units/is_scalar.adoc[`is&lowbar;scalar`]  [.small]#[deprecated]#
| Deprecated, no longer necessary&semi; kept only for backward compatibility&period;
| xref:mp_units/is_scoped_enum_v.adoc[`is&lowbar;scoped&lowbar;enum&lowbar;v`] 
| Whether `T` is a scoped enumeration type
| xref:mp_units/is_specialization_of-06.adoc[`is&lowbar;specialization&lowbar;of`] 
| Whether `T` is a specialization of the class template `Type`, which takes a pack of type parameters
| xref:mp_units/is_specialization_of-0b.adoc[`is&lowbar;specialization&lowbar;of`] 
| Specialization confirming that `Type&lt;Params&period;&period;&period;&gt;` is a specialization of `Type`
| xref:mp_units/is_specialization_of_v-01.adoc[`is&lowbar;specialization&lowbar;of&lowbar;v`] 
| Whether `T` is a specialization of the class template `Type`, which takes a pack of non&hyphen;type (`auto`) parameters
| xref:mp_units/is_specialization_of_v-08.adoc[`is&lowbar;specialization&lowbar;of&lowbar;v`] 
| Specialization confirming that `Type&lt;Params&period;&period;&period;&gt;` is a specialization of `Type`
| xref:mp_units/is_tensor.adoc[`is&lowbar;tensor`]  [.small]#[deprecated]#
| Deprecated, no longer necessary&semi; kept only for backward compatibility&period;
| xref:mp_units/is_value_preserving.adoc[`is&lowbar;value&lowbar;preserving`]  [.small]#[deprecated]#
| Specifies if a specific conversion between two types is representable without data loss
| xref:mp_units/is_vector.adoc[`is&lowbar;vector`]  [.small]#[deprecated]#
| Deprecated, no longer necessary&semi; kept only for backward compatibility&period;
| xref:mp_units/kind_of.adoc[`kind&lowbar;of`] 
| The quantity kind of the hierarchy tree rooted at the quantity specification `Q`
| xref:mp_units/known_first_factor.adoc[`known&lowbar;first&lowbar;factor`]  [.small]#[deprecated]#
| Deprecated placeholder retained for source compatibility
| xref:mp_units/mag-03.adoc[`mag`] 
| A Magnitude constant equal to the value `V`
| xref:mp_units/mag-08.adoc[`mag`] 
| A Magnitude constant equal to the value `V`
| xref:mp_units/mag_pi.adoc[`mag&lowbar;pi`]  [.small]#[deprecated]#
| Deprecated alias for the pi Magnitude constant
| xref:mp_units/mag_power.adoc[`mag&lowbar;power`] 
| Create a Magnitude which is some rational number raised to a rational power&period;
| xref:mp_units/mag_ratio.adoc[`mag&lowbar;ratio`] 
| A Magnitude constant equal to the rational number `N` &sol; `D`
| xref:mp_units/magnitude.adoc[`magnitude`] 
| Customization point object computing the magnitude of a representation value
| xref:mp_units/modulus.adoc[`modulus`] 
| Customization point object returning the modulus (absolute value) of a complex&hyphen;like value&period;
| xref:mp_units/natural_point_origin.adoc[`natural&lowbar;point&lowbar;origin`] 
| The point origin located at the zero point of a quantity specification
| xref:mp_units/non_negative-0d.adoc[`non&lowbar;negative`] 
| The unique instance of the `non&lowbar;negative` tag property&period;
| xref:mp_units/numeric_field-06.adoc[`numeric&lowbar;field`] 
| The numeric field of a representation type&colon; real or complex&period;
| xref:mp_units/numeric_field-08.adoc[`numeric&lowbar;field`] 
| Detects `numeric&lowbar;field` for a type whose tensor order is known and whose field is consistent&period;
| xref:mp_units/one-07.adoc[`one`] 
| The unique instance of the unit one&period;
| xref:mp_units/parts_per_million-0a.adoc[`parts&lowbar;per&lowbar;million`] 
| The unique instance of the parts&hyphen;per&hyphen;million unit&period;
| xref:mp_units/per_mille-08.adoc[`per&lowbar;mille`] 
| The unique instance of the per mille unit&period;
| xref:mp_units/percent-0a.adoc[`percent`] 
| The unique instance of the percent unit&period;
| xref:mp_units/pi-0f.adoc[`pi`] 
| The unique instance of the π constant&period;
| xref:mp_units/pi_c-0e.adoc[`pi&lowbar;c`] 
| The unique instance of the pi magnitude constant&period;
| xref:mp_units/possibly_negative-01.adoc[`possibly&lowbar;negative`] 
| The unique instance of the `possibly&lowbar;negative` tag property&period;
| xref:mp_units/ppm.adoc[`ppm`] 
| Alias for `parts&lowbar;per&lowbar;million`
| xref:mp_units/real.adoc[`real`] 
| Customization point object returning the real part of a complex&hyphen;like value&period;
| xref:mp_units/reference_for.adoc[`reference&lowbar;for`] 
| Public helper that yields the reference (unit &plus; quantity spec) associated with a quantity&hyphen;like type&period;
| xref:mp_units/rounded.adoc[`rounded`] 
| Rounding policy that rounds to the nearest representable value, to even in halfway cases
| xref:mp_units/rounded_down.adoc[`rounded&lowbar;down`] 
| Rounding policy that rounds towards negative infinity
| xref:mp_units/rounded_up.adoc[`rounded&lowbar;up`] 
| Rounding policy that rounds towards positive infinity
| xref:mp_units/space_before_unit_symbol.adoc[`space&lowbar;before&lowbar;unit&lowbar;symbol`] 
| Puts a space &apos; &apos; sign before a unit symbol
| xref:mp_units/tensor_order-04.adoc[`tensor&lowbar;order`] 
| The intrinsic tensor order of a representation type&colon; 0 for scalar, 1 for vector, 2 for tensor&period;
| xref:mp_units/tensor_order-0b.adoc[`tensor&lowbar;order`] 
| Structural detection of `tensor&lowbar;order` for a type exposing exactly one indexing shape&period;
| xref:mp_units/treat_as_floating_point.adoc[`treat&lowbar;as&lowbar;floating&lowbar;point`] 
| Specifies if a value of a type should be treated as a floating&hyphen;point value
| xref:mp_units/truncated.adoc[`truncated`] 
| Rounding policy that rounds towards zero for an integral destination
| xref:mp_units/unit_for.adoc[`unit&lowbar;for`] 
| Public helper that yields the unit associated with a quantity&hyphen;like type&period;
| xref:mp_units/zeroth_point_origin.adoc[`zeroth&lowbar;point&lowbar;origin`]  [.small]#[deprecated]#
| Deprecated alias for `natural&lowbar;point&lowbar;origin`
| xref:mp_units/π.adoc[`π`] 
| Alias for `pi`
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:mp_units/Dimension.adoc[`Dimension`] 
| A concept matching all dimensions in the library&period;
| xref:mp_units/DimensionOf.adoc[`DimensionOf`] 
| A concept checking if the argument is of the same dimension&period;
| xref:mp_units/MeasuredConstant.adoc[`MeasuredConstant`] 
| A concept matching constants that are measured rather than exact by definition
| xref:mp_units/PointOrigin.adoc[`PointOrigin`] 
| A concept matching all quantity point origins in the library
| xref:mp_units/PointOriginFor.adoc[`PointOriginFor`] 
| A concept matching all quantity point origins for a specified quantity type in the library
| xref:mp_units/PrefixableUnit.adoc[`PrefixableUnit`] 
| A concept to be used to define prefixes for a unit
| xref:mp_units/Quantity-0c.adoc[`Quantity`] 
| A concept matching all quantities in the library
| xref:mp_units/QuantityLike.adoc[`QuantityLike`] 
| A concept matching all external quantities like types
| xref:mp_units/QuantityOf.adoc[`QuantityOf`] 
| A concept matching all quantities of the provided quantity spec
| xref:mp_units/QuantityPoint.adoc[`QuantityPoint`] 
| A concept matching all quantity points in the library
| xref:mp_units/QuantityPointLike.adoc[`QuantityPointLike`] 
| A concept matching all external quantity point like types
| xref:mp_units/QuantityPointOf.adoc[`QuantityPointOf`] 
| A concept matching all quantity points of the provided property
| xref:mp_units/QuantitySpec.adoc[`QuantitySpec`] 
| A concept matching all quantity specifications in the library
| xref:mp_units/QuantitySpecOf.adoc[`QuantitySpecOf`] 
| A concept matching all quantity specifications of a provided quantity spec value
| xref:mp_units/Reference-0ba.adoc[`Reference`] 
| A concept matching all references in the library&period;
| xref:mp_units/ReferenceOf.adoc[`ReferenceOf`] 
| A concept matching all references of the provided quantity spec
| xref:mp_units/RepresentationOf.adoc[`RepresentationOf`] 
| Concept matching a representation type suitable for a quantity specification or character
| xref:mp_units/RoundingPolicy.adoc[`RoundingPolicy`] 
| A concept matching all rounding policies
| xref:mp_units/Unit.adoc[`Unit`] 
| A concept matching all unit types in the library
| xref:mp_units/UnitMagnitude.adoc[`UnitMagnitude`] 
| Concept to detect whether T is a valid UnitMagnitude&period;
| xref:mp_units/UnitOf.adoc[`UnitOf`] 
| A concept matching all units associated with the provided quantity spec
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
