Global namespace

Namespaces

Name
`mp_units`

mp_units namespace

Types

Name	Description
`absolute_point_origin`
`base_dimension`	A dimension of a base quantity
`basic_fixed_string`	A compile-time fixed string
`binomial_distribution`
`binomial_distribution`
`cartesian_vector`
`cauchy_distribution`
`cauchy_distribution`
`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.
`chi_squared_distribution`
`chi_squared_distribution`
`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
`constrained`	A transparent wrapper that carries an error policy for domain constraint enforcement.
`constraint_violation_handler`	Customization point for handling domain constraint violations.
`constraint_violation_handler<constrained<T, ErrorPolicy>>`
`constraint_violation_handler<safe_int<T, ErrorPolicy>>`
`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
`discrete_distribution`
`discrete_distribution`
`exponential_distribution`
`exponential_distribution`
`extreme_value_distribution`
`extreme_value_distribution`
`fisher_f_distribution`
`fisher_f_distribution`
`gamma_distribution`
`gamma_distribution`
`geometric_distribution`
`geometric_distribution`
`is_kind`
`kind_of_`
`kind_of_<Q>`
`lognormal_distribution`
`lognormal_distribution`
`mag_constant`
`named_constant`	Named constant definition
`named_unit`	A named unit
`named_unit<Symbol, U>`	Specialization for unit of a specified base quantity
`named_unit<Symbol, U, QS>`	Specialization for a unit with special name valid only for a specific quantity
`named_unit<Symbol, U, QS, PO>`
`natural_point_origin_`
`negative_binomial_distribution`
`negative_binomial_distribution`
`non_negative`
`normal_distribution`
`normal_distribution`
`one`	Unit one
`parts_per_million`
`per`	Type list type storing the list of components with negative exponents
`per_mille`
`percent`
`pi`
`pi_c`
`piecewise_constant_distribution`
`piecewise_constant_distribution`
`piecewise_linear_distribution`
`piecewise_linear_distribution`
`poisson_distribution`
`poisson_distribution`
`power`	Type container for exponents with ratio different than `1`
`prefixed_unit`	A prefixed unit
`quantity`	A quantity
`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`
`quantity_spec<QS, Args...>`
`quantity_spec<QS, Eq, Args...>`
`reference`	Quantity reference type
`reflect_in_range`	Policy that reflects (folds) the value at both boundaries.
`relative_point_origin`
`representation_underlying_type`	Describes the underlying arithmetic/element type of a representation type.
`representation_underlying_type<T>`
`representation_underlying_type<T const>`
`representation_values`	A type trait that defines zero, one, min, and max for a representation type
`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).
`scaled_unit`	Unit being a scaled version of another unit
`student_t_distribution`
`student_t_distribution`
`symbol_text`	A symbol text representation
`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).
`uniform_int_distribution`
`uniform_int_distribution`
`uniform_real_distribution`
`uniform_real_distribution`
`unit_symbol_formatting`
`weibull_distribution`
`weibull_distribution`
`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`
`rep_for`	Public alias that yields the representation type of a quantity-like type.
`representation_underlying_type_t`
`safe_i16`
`safe_i32`
`safe_i64`
`safe_i8`
`safe_u16`
`safe_u32`
`safe_u64`
`safe_u8`
`text_encoding`
`zeroth_point_origin_`

Enums

Name	Description
`character_set`
`quantity_character`	Quantity character
`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`	Computes the smallest quantity with integer representation and unit type To with its number not less than q
`contains`
`default_point_origin`
`delta`
`dimension_symbol`
`dimension_symbol_to`
`epsilon`	Returns the epsilon of the quantity
`exp`	Computes Euler's raised to the given power
`explicitly_convertible`
`floor`	Computes the largest quantity with integer representation and unit type To with its number not greater than q
`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`
`is_gt_zero`
`is_gteq_zero`
`is_integral_scaling`	Returns `true` if the scaling factor from `from` to `to` is an exact positive integer.
`is_lt_zero`
`is_lteq_zero`
`is_neq_zero`
`is_non_negative`
`isfinite`	`isfinite` overloads
`isinf`	`isinf` overloads
`isnan`	`isnan` overloads
`lerp`	Linear interpolation or extrapolation
`magnitude`
`midpoint`	Computes the midpoint of two points
`norm`
`operator%`	Modulus operators
`operator*`	Multiplication operators
`operator+`	Unary plus operators
`operator-`	Unary minus 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`	Computes the nearest quantity with integer representation and unit type `To` to `q`
`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`
`unit_vector`
`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_real`	//////////// REAL SCALAR ///////////////
`disable_real<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`
`is_derived_from_specialization_of`
`is_derived_from_specialization_of_v`
`is_kind`
`is_same_v`
`is_same_v<T, T>`
`is_scalar`
`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`
`is_value_preserving`	Specifies if a specific conversion between two types is representable without data loss
`is_vector`
`kind_of`
`known_first_factor`	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
`mag<>`
`mag`
`mag_pi`
`mag_power`	Create a Magnitude which is some rational number raised to a rational power.
`mag_ratio`
`magnitude`
`modulus`
`natural_point_origin`
`non_negative`
`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
`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`
`π`

Concepts

Name	Description
`ConstraintPolicy`
`Dimension`	A concept matching all dimensions in the library.
`DimensionOf`	A concept checking if the argument is of the same dimension.
`OverflowPolicy`
`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

Deduction Guides

Name
`basic_fixed_string<CharT, N - 1>`
`basic_fixed_string<CharT, 1 + sizeof...(Rest)>`
`basic_fixed_string<CharT, N>`
`cartesian_vector<std::common_type_t<Arg, Args...>>`
`quantity<quantity_like_traits<Q>::reference, quantity_like_traits<Q>::rep>`
`quantity<R, Value>`
`quantity<R{}, Value>`
`quantity_point<Q::reference, default_point_origin(Q::reference), Q::rep>`
`quantity_point<quantity_point_like_traits<QP>::reference, quantity_point_like_traits<QP>::point_origin, quantity_point_like_traits<QP>::rep>`
`quantity_point<Q::reference, PO{}, Q::rep>`
`safe_int<T>`
`symbol_text<1, 1>`
`symbol_text<N, N>`
`symbol_text<N - 1, N - 1>`
`symbol_text<N, M>`
`symbol_text<N - 1, M - 1>`