Global namespace

Namespaces

Name
`mp_units`

mp_units namespace

Namespaces

Name	Description
`utility`

Types

Name	Description
`absolute_point_origin`
`base_dimension`	A dimension of a base quantity
`basic_fixed_string`	A compile-time fixed string
`check_in_range`	Policy that checks the value is within [min, max]and reports violations.
`check_non_negative`	Policy that checks the value is ≥ 0 and reports violations.
`clamp_non_negative`	Policy that clamps the value to [0, ∞).]
`clamp_to_range`	Policy that clamps the value to [min, max].
`common_unit`	Measurement unit for an accumulation of two quantities of different units
`constraint_violation_handler`	Customization point for handling domain constraint violations.
`derived_dimension`	A dimension of a derived quantity
`derived_quantity_spec`	A specification of a derived quantity
`derived_unit`	Measurement unit for a derived quantity
`dimension_one`	Dimension one
`dimension_symbol_formatting`
`dimensionless`	Quantity of dimension one
`is_kind`
`kind_of_`
`mag_constant`
`named_constant`	Named constant definition
`named_unit`	A named unit
`natural_point_origin_`
`non_negative`
`one`	Unit one
`parts_per_million`
`per`	Type list type storing the list of components with negative exponents
`per_mille`
`percent`
`pi`
`pi_c`
`power`	Type container for exponents with ratio different than `1`
`prefixed_unit`	A prefixed unit
`quantity`	A quantity
`quantity_character`	Quantity character
`quantity_like_traits`	Provides support for external quantity-like types
`quantity_point`	A quantity point
`quantity_point_like_traits`	Provides support for external quantity point-like types
`quantity_spec`
`reference`	Quantity reference type
`reflect_in_range`	Policy that reflects (folds) the value at both boundaries.
`relative_point_origin`
`representation_canonical_type`	Maps a representation value type to the concrete type a quantity should store.
`representation_underlying_type`	Describes the underlying arithmetic/element type of a representation type.
`representation_values`	A type trait that defines zero, one, min, and max for a representation type
`scaled_unit`	Unit being a scaled version of another unit
`symbol_text`	A symbol text representation
`unit_symbol_formatting`
`vector_axes`	Ordered list of the 1D-vector component axes a vector quantity decomposes into
`vector_components`	Opts a vector quantity into decomposition into named 1D-vector components
`wrap_to_range`	Policy that wraps the value into the half-open range [min, max).]

Type Aliases

Name	Description
`conditional`
`expr_type`
`fixed_string`
`fixed_u16string`
`fixed_u32string`
`fixed_u8string`
`fixed_wstring`
`is_same`
`quantity_values` [deprecated]
`rep_for`	Public alias that yields the representation type of a quantity-like type.
`representation_canonical_type_t`
`representation_underlying_type_t`
`text_encoding` [deprecated]
`zeroth_point_origin_` [deprecated]

Enums

Name
`character_set`
`quantity_character_legacy` [deprecated]
`quantity_field`
`quantity_tensor_order`
`unit_symbol_separator`
`unit_symbol_solidus`

Functions

Name	Description
`abs`	Computes the absolute value of a quantity
`absolute`
`castable`
`cbrt`	Computes the cubic root of a quantity
`ceil`	`ceil` overloads
`contains`
`default_point_origin`
`delta`
`dimension_symbol`
`dimension_symbol_to`
`epsilon` [deprecated]	Returns the epsilon of the quantity
`exp`	Computes Euler's raised to the given power
`explicitly_convertible`
`floor`	`floor` overloads
`fma`	`fma` overloads
`fmod`	Computes the floating-point remainder of the division operation x / y.
`get`
`get_canonical_unit`
`get_common_quantity_spec`
`get_common_reference`
`get_common_unit`
`get_kind`
`get_quantity_spec`
`get_unit`
`hypot`	`hypot` overloads
`implicitly_convertible`
`interconvertible`
`inverse`	Computes the inverse of a quantity in a provided unit
`is_eq_zero` [deprecated]
`is_gt_zero` [deprecated]
`is_gteq_zero` [deprecated]
`is_integral_scaling`	Returns `true` if the scaling factor from `from` to `to` is an exact positive integer.
`is_lt_zero` [deprecated]
`is_lteq_zero` [deprecated]
`is_neq_zero` [deprecated]
`is_non_negative`
`isfinite`	`isfinite` overloads
`isinf`	`isinf` overloads
`isnan`	`isnan` overloads
`lerp`	Linear interpolation or extrapolation
`midpoint`	Computes the midpoint of two points
`operator*`	Multiplication operators
`operator+`	Addition operators
`operator/`	Division operators
`point`
`pow`	Computes the value of a quantity raised to the `Num/Den` power
`quantity_cast`	`quantity_cast` overloads
`remainder`	Computes the IEEE remainder of the floating point division operation x / y.
`round`	`round` overloads
`scale`	Scale `value` by the unit magnitude passed as `m,` converting to type `To.`
`sqrt`	Computes the square root of a quantity
`swap`
`unit_symbol`
`unit_symbol_to`
`value_cast`	`value_cast` overloads
`operator<<`	Stream insertion operators
`operator==`	Equality operators
`operator<=>`	Three-way comparison operators

Variables

Name	Description
`dimension_one`
`dimensionless`	Quantity of dimension one
`disable_representation`
`disable_representation<bool>`
`frame_projection`	User-specializable variable template for runtime coordinate frame transformations.
`imag`
`implicitly_scalable`	Controls whether conversion from `quantity<FromUnit, FromRep>` to `quantity<ToUnit, ToRep>` is implicit or explicit.
`is_complex` [deprecated]
`is_derived_from_specialization_of`
`is_derived_from_specialization_of_v`
`is_kind`
`is_same_v`
`is_same_v<T, T>`
`is_scalar` [deprecated]
`is_scoped_enum_v`
`is_specialization_of`
`is_specialization_of<Type<Params...>, Type>`
`is_specialization_of_v`
`is_specialization_of_v<Type<Params...>, Type>`
`is_tensor` [deprecated]
`is_value_preserving` [deprecated]	Specifies if a specific conversion between two types is representable without data loss
`is_vector` [deprecated]
`kind_of`
`known_first_factor` [deprecated]	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
`mag<>`
`mag`
`mag_pi` [deprecated]
`mag_power`	Create a Magnitude which is some rational number raised to a rational power.
`mag_ratio`
`magnitude`
`modulus`
`natural_point_origin`
`non_negative`
`numeric_field`
`numeric_field<T>`
`one`
`parts_per_million`
`per_mille`
`percent`
`pi`
`pi_c`
`ppm`
`real`
`reference_for`	Public helper that yields the reference (unit + quantity spec) associated with a quantity-like type.
`space_before_unit_symbol`	Puts a space ' ' sign before a unit symbol
`tensor_order`
`tensor_order<T>`
`treat_as_floating_point`	Specifies if a value of a type should be treated as a floating-point value
`unit_for`	Public helper that yields the unit associated with a quantity-like type.
`zeroth_point_origin` [deprecated]
`π`

Concepts

Name	Description
`Dimension`	A concept matching all dimensions in the library.
`DimensionOf`	A concept checking if the argument is of the same dimension.
`PointOrigin`	A concept matching all quantity point origins in the library
`PointOriginFor`	A concept matching all quantity point origins for a specified quantity type in the library
`PrefixableUnit`	A concept to be used to define prefixes for a unit
`Quantity`	A concept matching all quantities in the library
`QuantityLike`	A concept matching all external quantities like types
`QuantityOf`	A concept matching all quantities of the provided quantity spec
`QuantityPoint`	A concept matching all quantity points in the library
`QuantityPointLike`	A concept matching all external quantity point like types
`QuantityPointOf`	A concept matching all quantity points of the provided property
`QuantitySpec`
`QuantitySpecOf`	A concept matching all quantity specifications of a provided quantity spec value
`Reference`	A concept matching all references in the library.
`ReferenceOf`	A concept matching all references of the provided quantity spec
`RepresentationOf`
`Unit`	A concept matching all unit types in the library
`UnitMagnitude`	Concept to detect whether T is a valid UnitMagnitude.
`UnitOf`	A concept matching all units associated with the provided quantity spec

mp_units::utility namespace

Namespaces

Name
`detail`

Types

Name	Description
`constrained`	A transparent wrapper that carries an error policy for domain constraint enforcement.
`safe_int`	Wraps an integral type with overflow detection.
`safe_int_terminate_policy`	Error policy that terminates the program on overflow (always available, freestanding-safe).
`safe_int_throw_policy`	Error policy that throws std::overflow_error on overflow (hosted only).
`terminate_policy`	Error policy that terminates the program on constraint violation (freestanding-safe).
`throw_policy`	Error policy that throws std::domain_error on constraint violation (hosted only).
`unspecified_t`	Sentinel default for a specializable variable-template customization point with no usable default.

Type Aliases

Name
`safe_i16`
`safe_i32`
`safe_i64`
`safe_i8`
`safe_u16`
`safe_u32`
`safe_u64`
`safe_u8`

Functions

Name	Description
`operator%`	Modulus operators
`operator*`	Multiplication operators
`operator+`	Unary plus operators
`operator-`	Unary minus operators
`operator/`	Division operators
`operator<<`	Stream insertion operator
`operator==`	Equality operators
`operator<=>`	Three-way comparison operators

Variables

Name
`unspecified`

Concepts

Name	Description
`Complex`	A complex-field representation type.
`ComplexScalar`	A complex scalar: complex field with `real()`/`imag()`/`modulus()`.
`ConstraintPolicy`
`OverflowPolicy`
`Real`	A real-field representation type.
`RealScalar`	A real scalar (tensor order 0): real field, totally ordered, self-scalable.
`Scalar`	A scalar (real or complex, tensor order 0) - the element type a vector/tensor is built from.
`Tensor`	A second-order tensor (or a lower-order type filling its slot).
`Vector`	A vector (a scalar, or a magnitude-bearing tensor-order-1 type).
`specified`	Satisfied when a customization point has been given a value (i.e. is not `unspecified`).

mp_units::utility::detail namespace

Types

Name
`constrained_binary_ops`
`safe_int_binary_ops`
`underlying_int_type_helper`

Type Aliases

Name
`integral_op_result_t`
`underlying_int_type_t`

Functions

Name	Description
`add_overflows`
`checked_int_cast`
`div_overflows`
`int_in_range`
`mul_overflows`
`neg_overflows`
`operator%`	Modulus operators
`operator*`	Multiplication operators
`operator+`	Addition operators
`operator-`	Subtraction operators
`operator/`	Division operators
`sub_overflows`
`operator==`	Equality operators
`operator<=>`	Three-way comparison operators

Variables

Name
`is_safe_int_v`
`is_value_preserving_int_v`
`is_value_preserving_v`
`same_sign_v`

Using Namespace Directives

Name
/* implementation-defined */