Release Notes

This page documents the version history and changes for the mp-units library.

mp-units

2.6.0 TBD

• fix: the displacement between two point origins keeps a named unit that already is the coarsest exact one, so a -27 cm origin offset and the point differences across it print in cm rather than in (1/100 m)
• refactor: quantity_from() and quantity_from_zero() of a quantity point are renamed to delta_from() and delta_from_zero(). They return a delta, and once a point is a quantity too, "quantity from" no longer says which one. The former names are deprecated
• fix: magnitude of an unsigned value returns the value, where it called std::abs, which has no unsigned overload
• (!) refactor: char, wchar_t, char8_t, char16_t, and char32_t are not representation types, as bool isn't. A character type holds a character, not a number, so quantity<si::metre, char> is ill-formed. signed char and unsigned char, the types of std::int8_t and std::uint8_t, stay representation types
• feat: a vector quantity composes from a single value holding its components, the inverse of its tuple protocol: quantity<flight_velocity[km / h], vec3> v = std::tuple{fwd, lat, vert};. Any type a structured binding decomposes through std::tuple_size is accepted, its elements read as such a binding reads them, through a member get or one found by argument-dependent lookup, so a third-party vector works, which std::make_from_tuple cannot do. The rules are those of the component-wise constructor, element by element, and the conversion is implicit like it. A quantity, a point, a QuantityLike type, and a value convertible to the representation are not composed this way, and the deleted truncating constructor of a quantity of unit one no longer takes such a value for a number
• refactor: the customization point that declares the axes of a vector quantity is component_vectors, after the term ISO 80000-2 uses for the vectors a₁e₁, a₂e₂, and a₃e₃ of a vector. The former name vector_components is deprecated. A specialization of it still declares the axes
• (!) refactor: the quantity specification conversion engine is reimplemented from a written specification, the new chapter Quantity Specification Conversions. Conversions between two named quantities are unchanged, except where the definitions listed below changed or the source carries, through its equation, a declared kind its target doesn't: isq::period_of_binary_digits carries storage_capacity and converts to isq::duration only explicitly, as an angle per length does to 1 / length. Where quantity equations or kinds take part, a few patterns that used to compile now need an explicit conversion or are ill-formed. A declared kind (is_kind) is a boundary in both directions: quantity<isq::angular_measure[rad]> a = isq::arc_length(arc) / isq::radius(r); needs isq::angular_measure(...), isq::arc_length from angle * r needs quantity<isq::arc_length[m]>(angle * r), and a product of user-defined quantities needs an explicit conversion to a user-defined is_kind quantity like pixel_area. Under plain isq the rotational formulas P = τω and E = ½Iω² need the explicit constructor with a unit, quantity<isq::power[W]>(torque * omega) and quantity<isq::kinetic_energy[J]>(...), because ISQ defines torque without an angle and angular velocity with one, and the unit has to drop the angle as well. isq_angle keeps both implicit (see Strong Angular System). Converting to a kind is no longer more permissive than converting to the quantity it wraps: quantity<si::hertz> f = 1 / isq::time(duration); needs isq::frequency(...), while 1 / (2 * s) is unaffected. A kind of a declared sub-kind no longer converts to a sibling branch: isq::mean_queue_length(2 * rad) is ill-formed, convert it with quantity<dimensionless[one]>(...) first. Distinct roots of one dimension stay apart: quantity<Bq * kg> x = f_in_hertz * mass; is ill-formed. A factor common to both sides doesn't change how they relate, and paired factors keep their relation: siblings still need quantity_cast, and isq::energy * isq::time / isq::period_duration converts to isq::kinetic_energy explicitly, as isq::energy does. Conversion-heavy translation units compile in about 30 % less time (isq_test 17.8 s -> 12.5 s with GCC 15)
• fix: the inverse of an angle no longer converts implicitly to a plain number. 1 / isq::angular_measure to dimensionless drops the angle, so it is explicit, and an angle doesn't convert to its own inverse, even with quantity_cast
• (!) refactor: si::newton, si::pascal, si::joule, si::volt, si::farad, si::ohm, si::siemens, and si::tesla no longer carry a quantity kind. A named unit carries one where the SI brochure keeps the name for one quantity, Hz, Bq, Gy, Sv and kat, where the library needs it for its own distinctions, rad, sr, the base units, the photometric units, and IEC's var, bit, baud and erlang. So quantity<isq::torque[J]> is well-formed and 1 * J converts to a torque, as 1 * N * m always converted to an energy, while 1 * Hz still doesn't convert to an activity, nor Bq / m to a frequency per length. ISO 80000-1:2009 notes that the joule is not written for a moment of force, and that convention is left to the author
• fix: a product of typed quantities converts to its own unit again. omega * inertia with omega in rad / s has the unit kg m² rad/s, and a moment of inertia is defined over an angular velocity, so its specification takes the angle away that the velocity brings and the angle looked lost. For a kind source, what a factor's definition takes away now stays apart from what the other factors carry. The angle of rad / s also died against the rotation in rotation * angular_velocity before the velocity was expanded. From a kind source, a pairing that would refuse now waits for a factor that mentions the tree, however deep
• fix: a product of three typed quantities converts to its own unit when one of them is a dimensionless count. omega * inertia * turns, with turns an isq::rotation, can be read in kg m² rad/s again. After a sibling pairing from a kind source is deferred, the shallowest factor that has an equation is expanded first, so the angle of the unit meets the angular_velocity and not the rotation beside it
• fix: the kind boundary lowers every verdict between two named quantities, and between a named quantity and a kind, where it used to lower only an implicit verdict, and from a kind none at all. A kind_of<isq::angular_velocity> converts to a child defined as inverse(isq::duration) only explicitly, and two siblings that each carry a declared kind the other lacks don't convert, as their squares already didn't
• (!) fix: ISQ definitions corrected against ISO/IEC 80000. isq::angular_repetency is phase_angle / wavelength (k = 2π/λ, like angular_frequency), so a phase speed ω/k converts to length / time implicitly and 1 / wavelength is an angular repetency only explicitly. isq::inductance, isq::mutual_inductance and isq::reluctance are defined over total_magnetic_flux (IEC 80000-6 items 6-41.1, 6-41.2 and 6-39) instead of protoflux and magnetic_flux. isq::entropy is heat / thermodynamic_temperature, the thermodynamic definition dS = δQ/T, instead of kinetic_energy / .... isq::magnetic_constant and isq::electric_constant are children of permeability and permittivity (IEC 80000-6 items 6-26.1 and 6-14.1), so relative_permeability and relative_permittivity are ratios within one tree. isq::propagation_coefficient is a complex quantity with isq::attenuation and isq::phase_coefficient as its real children (ISO 80000-3 item 3-26). The phase coefficient carries a phase angle that the propagation coefficient doesn't, so it converts to its parent only explicitly. isq::isothermal_compressibility and isq::isentropic_compressibility are no longer is_kind: ISO 80000-4 item 4-20 treats them as compressibility under a stated condition, so both convert to isq::compressibility implicitly and to each other with quantity_cast
• fix: the converting constructor of quantity no longer asks the source for its value in the source's own unit, so a product whose unit carries more angles than its quantity specification (moment_of_inertia * pow<2>(angular_velocity) in kg m² rad²/s²) converts to quantity<isq::kinetic_energy[J]>
• fix: a ratio of two quantities of one dimension converts to dimensionless again (isq::width * isq::height / isq::area)
• fix: kind_of<K> relates to a target through K itself, with its downcasts promoted
• (!) fix: natural::speed is no longer is_kind. It is the plain ratio v/c, so it converts to dimensionless implicitly
• refactor: iau::parsec is defined as exactly 648 000/π astronomical units instead of an astronomical unit per arcsecond. The numeric value is unchanged
• fix: the deprecated encoding member of unit_symbol_formatting and dimension_symbol_formatting is available on Clang again. The library left it out there to avoid a spurious deprecation warning from the implicit copy constructor, so setting it did not compile on Clang and char_set did not take its value. Using it now warns on every compiler
• fix: Clang with libstdc++ 12, which has no <format>, now hits the "std::formatting facility not supported" error when std::format is selected. The check used to skip every Clang to accommodate libc++ before 20, which provides <format> without defining __cpp_lib_format. It now skips only that library
• fix: the deprecated mp_units::cartesian_vector and random-distribution aliases warn on GCC 12 as well. They were plain using-declarations there
• fix: Clang diagnostics print the representation type of a deduced quantity or quantity_point, and of the std::common_type of two quantities, as the plain type (int) instead of the library's internal spelling (representation_canonical_type_t<int>, typename Q::rep, or std::common_type_t<short, unsigned char>). Multiplying or dividing a unit by a quantity now states why it is ill-formed, as multiplying a unit by a number already did.
• fix: a rejected +, -, %, == or <=> on two quantities of different kinds, and a rejected hypot, report that the quantities have no common quantity instead of an invalid call to get_common_reference. Three more mistakes get a sentence: a raw number in +, - or % with a dimensioned quantity, quantity_from() with an unrelated origin, and quantity_from_zero() on a point whose origin is not the natural one. A QuantityOf, QuantitySpecOf or QuantityPointOf asked with a quantity specification no longer explains the rejected character branch through every std::is_same_v under it, which cut Clang's notes for a mismatched QuantityOf parameter from 149 lines to 31
• fix: a quantity or a point that meets a representation constraint is rejected in one note (!disable_representation<…>) instead of three layers of representation concepts, a vector added to a scalar quantity of the same kind reports the representations that have no sum instead of an ill-formed std::invoke_result, and a representation whose character the quantity does not admit fails a named CharacterAdmitted concept. Sentences now also name a quantity of another kind added to or subtracted from a point, a difference or comparison of points with unrelated origins, component-wise construction whose arguments do not fit the axes, fma, fmod and remainder on quantities of different kinds, floor, ceil, round and inverse to a unit of another kind, quantity_cast to a specification it cannot reach, value_cast to a quantity type of another specification, and a quantity specification called with a quantity it cannot convert or with a raw number when it is not dimensionless
• fix: a conversion whose scaling factor overflows the representation type, such as `1
  • Zm + 1 * amwithint, is an unsatisfied constraint on Clang as it is on GCC. It was a hard error there, sincetry_get_valuereturned its disengagedstd::optional` by copy, which Clang rejects in constant evaluation with libstdc++
• fix: a named_unit given a quantity specification where a quantity kind is required, named_unit<"x", isq::length> instead of named_unit<"x", kind_of<isq::length>>, fails the NamedUnitArguments constraint with a sentence naming kind_of instead of as an incomplete type
• feat: the concepts for symbolic types accept a const-qualified type, the way the standard's type categories do. Unit<decltype(si::metre)> and QuantitySpec<decltype(isq::length)> now hold, just as Quantity<const Q> always did. Only a non-const type may enter a symbolic expression, so si::kilo_<const metre> and derived_unit<const metre, per<second>> are still rejected, and dividing a const second by a second still gives one
• (!) refactor: character_set enumerators renamed back to unicode and basic, following SG16 review of P3045. The enumeration names a character set, not an encoding, so utf8 was the wrong name: UTF-8 is one encoding of Unicode, and which encoding is used is decided by the output type rather than by this selector. utf8 and portable remain as deprecated aliases with unchanged values, as does ascii
• (!) refactor: every default_* enumerator is deprecated, again following SG16 review of P3045: character_set::default_character_set, unit_symbol_solidus::default_solidus and unit_symbol_separator::default_separator (and the older character_set::default_encoding). A name that tracks the default silently changes meaning whenever the default moves, so spell the value you want. unit_symbol_formatting and dimension_symbol_formatting now initialize their members with the concrete values those defaults pointed at, so behaviour is unchanged
• (!) feat: a quantity kind admits every character. A kind spans its whole quantity tree (the kind of isq::speed holds the scalar isq::speed and the vector isq::velocity alike), and a simple quantity is of a kind as well, since the specification its unit yields is a kind_of<…>. Only the representation can restrict a kind's character, so cartesian_vector{3., 4., 0.} * m / s is a vector quantity of the kind of m / s, and a kind stored in double admits every order. magnitude() exists when the quantity may be a vector or a tensor and its representation can produce a norm, and never on a concrete scalar such as isq::speed
• (!) feat: QuantityOf, QuantityPointOf, QuantitySpecOf, and ReferenceOf take a character in place of a quantity specification. QuantityOf and QuantityPointOf hold when the specification admits the character and the representation can fill the slot. QuantitySpecOf and ReferenceOf ask only the specification, which is how utility::polar_vector requires a scalar radius. A specification argument keeps its quantity-tree meaning
• (!) refactor: quantity_spec::character is deprecated in favour of the character-taking concepts above, since a kind admits every character and a single value can't describe that. It reports the character of a concrete specification and is ill-formed for a kind such as kind_of<isq::speed> or the specification of m / s, where 2.5 reported the tree root's character. quantity::character and quantity_point::character exist only as deprecated members with the same rule, so they are ill-formed for every simple quantity such as 30.0 * km / h. MSVC up to 19.51 instantiates the initializer of every such member eagerly, so there none of these character members exist
• (!) refactor: quantity_spec::dimension is deprecated in favour of get_dimension(qs)
• feat: the GLM integration models the tuple protocol for glm::vec. GLM states a vector's length only through its static length(), so the plugin maps that onto std::tuple_size and adds the matching std::tuple_element and get<I>. A GLM vector is now structured-bindings friendly, and the polar_vector / spherical_vector facades accept one as a Cartesian source, which previously only cartesian_vector, blaze::StaticVector, and the Eigen plugin could do
• fix: classifying a container of quantities as a representation no longer risks a constraint-satisfaction cycle. HasMagnitude rejects a magnitude that is itself a quantity before probing scalability, which quantity's own operator*(const Value&, const quantity&) would otherwise turn into a recursive question about the very property being classified
• fix: the GLM integration header no longer breaks an import std; build. Its own GLM includes now precede the standard-library import, since GLM pulls in <cmath> textually and libstdc++ requires every such include to come first
• (!) fix: numerical_value_ref_in now constrains its unit the way in() and numerical_value_in() already did. It used to check only that the unit is equivalent, so for quantity f = 50. * Hz; the call f.numerical_value_ref_in(Bq) compiled and handed out the number of a frequency "in becquerel"
• (!) refactor: throwing constraints are off unless MP_UNITS_API_THROWING_CONSTRAINTS is enabled. The headers used to turn them on whenever __cpp_constexpr_exceptions was at least 202411L. Their message is formatted at compile time, which the library does only through {fmt}, so enabling them together with std::format now stops the CMake configure step, and an #error does the same for header-only use
• fix: the library compiles in a hosted build with exceptions disabled (-fno-exceptions). Text-formatting errors, basic_fixed_string::at and inplace_vector go through MP_UNITS_THROW, which aborts without exceptions. throw_policy and safe_int_throw_policy are provided only when exceptions are enabled, so constrained and safe_int default to the terminating policies otherwise. Throwing constraints fall back to plain constraint failures, without the formatted message. A new unit_tests_no_exceptions target builds every public header with -fno-exceptions
• fix: on GCC, type names in constraint diagnostics no longer end in ; std::string_view = std::basic_string_view<char>. The same suffix could make GCC order a type whose name is a prefix of another's differently from Clang when sorting the terms of a symbolic expression
• feat: vector quantity decomposition added. A vector quantity splits into 1D-vector component quantities through get<Idx>, std::tuple_size / std::tuple_element, and structured bindings, provided its representation offers element access (a member get<I>(), a get<I> found by argument-dependent lookup, or operator[], tried in that order) and states its length through std::tuple_size. Declaring the component axes, one per element of the representation, with the component_vectors customization point and vector_axes makes every component a distinct kind, reachable as get<Axis> and rejected in cross-axis arithmetic. The inverse is a component-wise constructor (quantity<flight_velocity[km / h], vec3> v = {fwd, lat, vert}), which checks each argument against the axis declared for its position, so a swapped pair of axis-typed arguments does not compile (a simple quantity fits every axis, as everywhere else in the library, and forfeits that check). Without such a declaration both directions remain available, with each component carrying the whole's kind and positions no longer told apart. The kind is what an undeclared decomposition actually knows: a component belongs to the whole's kind without being the whole, and since a kind now admits every character, the component keeps its vector character all the same
• (!) fix: isq::wave_vector now roots in angular_repetency instead of repetency. ISO 80000-3 defines the wave vector both ways (item 3-21 against item 3-22), but ISO 80000-12 item 12-9.1 and the relation k = p/ħ require k = 2π/λ, so the library sides with item 3-22
• (!) fix: hep::decay_constant is no longer a child of hep::frequency. A decay rate describes a stochastic process in which nothing oscillates, mirroring how the ISQ keeps activity out of the frequency family; hep::hertz no longer measures it
• (!) fix: isq::energy and isq::power no longer carry non_negative. Thermodynamic potentials, work done against a force, released heat, and exported electrical power are all negative, so tagging the two roots was wrong and every energy and power inherited the error. P4185 states this for energy explicitly. The genuinely non-negative members now carry the tag individually: isq::kinetic_energy, isq::photon_energy, isq::radiant_energy, isq::radiant_flux, isq::work_function, isq::ionization_energy, isq::gap_energy (and through it isq::superconductor_energy_gap), isq::carrier_power, isq::quantizing_distortion_power, and isq::signal_energy_per_binary_digit. isq::latent_heat is deliberately signed, since ISO 80000-5 item 5-6.2 defines it as energy released or absorbed
• feat: possibly_negative cancels the non_negative a real-scalar child would otherwise inherit from its parent. It is needed where a quantity shares its parent's kind, and therefore its units, but not its domain. ISO 80000-12 item 12-30 is the motivating case: an effective mass is negative near a band maximum, yet it must be expressed in kilograms, and only a quantity of the mass kind may be. Rooting it elsewhere loses the kilogram, so the two properties could not be modeled together before. isq::effective_mass now uses it. The tag and non_negative are mutually exclusive
• feat: ISO 80000-12 (condensed matter physics) is modeled in the new mp-units/systems/isq/condensed_matter_physics.h, covering 58 of the standard's 60 items: the crystal lattice, lattice dynamics, electron transport, electronic structure, carrier dynamics, and the magnetic and superconducting transitions. Item 12-2.1 (angular reciprocal lattice vector) is a wave_vector, so Bloch's theorem adding it to a wave vector type-checks. The carrier densities of item 12-29 share one kind, because item 12-29.3 relates them across species as n * p == pow<2>(n_i). Item 12-31 (mobility ratio) and item 12-33 (diffusion length) wait for ISO 80000-10 item 10-61 and ISO 80000-9 item 9-39, and item 12-14 (Grüneisen parameter) carries no defining equation until the logarithmic-quantities framework lands. ISO permits negative values for items 12-25, 12-27.1, 12-30, and 12-34, but they still inherit non_negative from energy and mass until a signed child of a non-negative parent can be expressed
• (!) perf: the ISQ part headers no longer pull in whole neighbouring parts to reach a handful of definitions. isq::power, isq::energy_density, isq::mass_density (with its density alias), and isq::speed_of_light_in_vacuum (with its light_speed_in_vacuum and luminal_speed aliases) moved to the new mp-units/systems/isq/shared_quantities.h, which records the owning ISO 80000 part for each. isq/light_and_radiation.h consequently includes neither isq/electromagnetism.h nor isq/mechanics.h, and isq/information_science_and_technology.h includes neither isq/mechanics.h nor isq/space_and_time.h. Parsing isq/light_and_radiation.h costs 51% less on GCC 15 and 52% less on Clang 21, isq/electromagnetism.h 15% less, and isq/information_science_and_technology.h 31% less; isq.h itself stays within 2% of its old cost, since it still defines everything. Every spelling is unchanged and isq.h still provides them all, but a translation unit that included one part header and reached a neighbouring part's quantity transitively now has to include that part itself. isq::energy_density is now defined over base quantities rather than as energy / volume, because its children are reached by unrelated equations (ISO 80000-8 item 8-7 gives sound energy density as ½ρu² + ½p²/(ρc²)); every equation form still converts
• feat: isq::number_of_entities (ISO 80000-9 item 9-1) is the shared root for every count of discrete entities. A count is a kind of its own, so it does not mix with plain dimensionless ratios. isq::photon_number is now an is_kind child of it: counts of photons do not mix with counts of other entities, while every count remains reachable from the shared root in generic code. The root opens the new mp-units/systems/isq/shared_quantities.h header, which holds the parents shared by quantities of more than one ISO 80000 part for the case when those parts must not depend on each other
• feat: isq::energy_density is the shared root for the energy densities of ISO 80000 parts 6, 7, and 8. isq::electromagnetic_energy_density and isq::radiant_energy_density are now its children, so they compare and convert through their common parent
• fix: get_dimension() and get_kind() on a derived quantity spec were not normalized when a base dimension was contributed by three or more factors, so get_dimension(isq::mass_density * isq::speed * isq::length / isq::dynamic_viscosity) did not equal dimension_one, making the canonical Reynolds equation impossible to write
• feat: mp-units/systems/si/unit_symbols_essential.h provides the SI unit symbols most code actually writes: every unprefixed symbol (base units, named derived units, and the non-SI units accepted for use with the SI) plus the prefixed spellings that are standard practice in some domain — fm and nm in physics, ns in electronics, hPa in meteorology, MPa in materials, kHz…THz in signals, the pF…mF capacitor and mΩ…GΩ resistor decades, µSv in radiation protection, and so on. The full unit_symbols.h includes it and adds the rest of the 24-prefix matrix, so both spell the very same types and may be mixed freely. 218 of the 771 spellings cost about a quarter of what all 771 do, because every prefixed symbol is a distinct type instantiated at parse time. si/core.h now includes the essential header
• perf: prefixed_unit derives from detail::scaled_unit_impl directly instead of reaching it through scaled_unit<M, U>::_base_type_. The base class is unchanged — it just no longer instantiates the scaled_unit specialization to name it, which is a quarter of the cost of every prefixed symbol. A si/unit_symbols.h translation unit drops 7.2% of its template instantiations, and si.h 6.5%
• feat: unary minus on a unit magnitude (-mag_ratio<N, D>, -mag<N>), which reads the way a published table prints a negative constant. It yields the same type as putting the sign in the numerator, and a second negation cancels
• fix: uncertain<T>::relative_uncertainty() now divides by the absolute value. GUM and the VIM define the relative standard uncertainty as u(x)/|x|, so it is never negative; it used to come out negative for a negative central value
• feat: compile-time factorization now handles composites of large primes: mul_mod uses a double-wide (128-bit) product where the compiler provides one, and find_first_factor finds factors with a batched-Brent Pollard's rho instead of unbounded trial division (which needed ~266k constexpr iterations for real CODATA mantissas, over GCC's default loop limit). Mirrors the approach validated in Au (aurora-opensource/au#686); trial division remains as the last-resort fallback
• perf: the whole unit_magnitude interface (operators and all queries) moved to hidden friends of a new non-template unit_magnitude_interface base, the same shape as unit_interface and quantity_spec_interface. A hidden friend of a class template is redeclared by every specialization, and magnitude-heavy code instantiates thousands of specializations per translation unit, so those declarations dominated compile times; in a non-template base they are declared once and cost nothing while keeping all hidden-friend benefits. A TU including si units and constants dropped from ~2.6 s to ~1.6 s, and the complete codata2022.h from ~40 s to ~4.1 s (GCC 15; Clang 21 shows 44 s -> 6.8 s)
• perf: the same interface-base treatment applied to the three remaining class templates that host hidden friends and are instantiated many times per translation unit: basic_fixed_string (10 friends, ~22 specializations in any TU that includes a system header, 98 for the full CODATA set), symbol_text (3 friends), and the two vector-component get() overloads on quantity (which cost 2 declarations per quantity specialization — 476 in a unit-composition-heavy TU). Declarations drop 2.1–3.3% of all function declarations per TU. Template instantiations are unchanged by construction: this is declaration cost, which no instantiation count can see
• perf: three compile-time costs of this release's framework extensions trimmed where the work was redundant. The sort predicates behind every quantity-spec and unit product compare type names with string_view::compare instead of the comparison operators, whose overload resolution probed the std::error_code converting constructors on each call: an isq.h umbrella translation unit evaluates about 24 % fewer constant expressions (Clang 23, C++26). The kinds-per-factor test of the spec operators is a variable template rather than a concept, because at -std=c++26 a concept's folds are normalized per operand (P2963) and re-evaluated the QuantitySpec atoms of every operand on every product. The component-wise quantity constructor orders its constraint cheapest-first, so the {value, reference} construction behind 42 * m no longer runs the decomposition checks of every new quantity type
• perf: four more cuts found by the same attribution. Unit, QuantitySpec, Dimension and PointOrigin check their base with is_base_of_v (one atom instead of derived_from's two) and fold the SymbolicConstant traits into one atom: the isq.h umbrella evaluates 12 % fewer constant expressions. type_list_size is a variable template specialization, so no class is instantiated per list (698 fewer instantiations in that umbrella). The framework reads _character_ and _dimension_ directly where it already holds the type instead of instantiating an accessor per type (651 fewer). prefixed_unit carries the two members of scaled_unit_impl itself instead of deriving from it, one class instantiation fewer for each of the ~670 prefixed symbols of si/unit_symbols.h
• perf: type_list_element, type_list_split and type_list_extract use the __type_pack_element builtin where the compiler provides it (Clang, GCC 14 and later), the C++20/23 counterpart of the C++26 pack-indexing path. The indexed multiple-inheritance trick they used costs three class instantiations per list on every spec or unit product; the isq.h umbrella drops 6.7 % of its instantiations and 14 % of its constant evaluations at C++23. GCC 12, GCC 13 and MSVC keep the trick. The factor ordering predicate of quantity specs is an expression rather than a function, one instantiation fewer per pair of factors compared
• perf: the first 100 primes that magnitude factorization starts from are a literal table. Computing them with a probable-prime test per candidate cost about 30 ms of constant evaluation in every translation unit that includes a system header, which charged even a TU that includes only the core and defines nothing
• perf: RepresentationOf matches the character inside a requires-expression behind its two guards, and disable_representation rejects a quantity or a quantity_point by a pattern-matched specialization. Clang substitutes the template arguments of every atom of a constraint whether it evaluates the atom or not, so a rejected type still had representable_character<T> instantiated for it, which evaluates Scalar, Vector and Tensor on the type: RepresentationOf on a point went from 2,707 constraint checks to 262. Measured on the benchmark corpus with no loss on any workflow; a wider rewrite of the operators' Value overloads around the same finding was measured as mixed on the gate and not kept
• fix: basic_fixed_string::swap never compiled — it called an undeclared swap_ranges through begin()/end(), which yield const_iterator and cannot be written through. Nothing called it, so it was never instantiated. It now exchanges the contents element-wise, and both it and the free swap are covered by tests
• (!) fix: the free swap for basic_fixed_string is now a hidden friend, so it is found only by ADL. mp_units::swap(a, b) no longer compiles; that spelling defeated the using std::swap; swap(a, b); customization mechanism and was never correct
• fix: symbol_text comparison against a raw char or string literal (sym == 'b', unit._symbol_ == "km") is preserved explicitly. It previously worked as a side effect of the comparison operators being members of the class template, which let the other operand reach them through symbol_text's converting constructors
• (!) feat: pi and π is now a unit constant
• (!) feat: iau::newtonian_constant_of_gravitation is now imported from codata::newtonian_constant_of_gravitation instead of being defined by the IAU system, and the iau::codata2018 inline namespace is gone. IAU 2015 Resolution B3 asks for the current best estimate of G, so the value now follows whichever adjustment is current. The value is unchanged today, since CODATA 2022 kept G at 6.674 30(15)e-11
• feat: CODATA fundamental physical constants added as a separate system with one namespace and one header per adjustment (codata::codata2014, codata::codata2018, and the inline codata::codata2022), GENERATED from the NIST "allascii" tables by scripts/codata_constants.py for complete coverage (~230 constants per adjustment): measured constants transcribe the published value and absolute standard uncertainty digit for digit, exact non-terminating values are defined by their exact symbolic relations, and an independent verification step recomputes every emitted value against its source row. Each adjustment ships in two tiers: mp-units/systems/codata/codataYYYY_essential.h (the NIST "frequently used" selection, cheap to compile) and mp-units/systems/codata/codataYYYY.h (the complete table, including the essential tier), with mp-units/systems/codata.h as the umbrella. Deliberately not part of si, so that mp-units/systems/si.h does not carry constants most code never names (#820)
• deprecated: si::standard_gravity. It is not an SI defining constant but a conventional value adopted by CGPM 3 (1901), which is what NIST's "adopted values" CODATA category holds; its home is now codata::standard_gravity from <mp-units/systems/codata/adopted_values.h>, a single adjustment-invariant entity shared by all CODATA namespaces (as are the standard atmosphere, the standard-state pressure, and the conventional Josephson and von Klitzing values). yard_pound's pound_force is now defined through the codata entity
• deprecated: si::reduced_planck_constant. ℏ is not an SI defining constant either; its home is codata::reduced_planck_constant, defined as the exact h / 2π relation in the post-2019 adjustments and as the measured "Planck constant over 2 pi" in codata2014
• deprecated: si::magnetic_constant. The pre-2019 SI defined the ampere through it, which made it exactly 4pi1e-7 H/m; since the redefinition it is measured. Its value is unchanged, but use codata::magnetic_constant for the current adjustment, or codata::codata2014::magnetic_constant for the exact pre-2019 one. These are NOT interchangeable with the hep constants of the same name, which belong to a different system of quantities
• deprecated: implicitly_convertible, explicitly_convertible and castable in mp_units. They are not proposed for standardization and have moved to mp_units::utility. ADL doesn't find them there, so qualify the call: utility::implicitly_convertible(isq::width, isq::length). A generic interface should constrain with QuantityOf or QuantityPointOf instead
• (!) refactor: pi_c, the magnitude constant behind the pi unit, is an implementation detail now. Use the pi unit instead, e.g., pi * metre rather than mag<pi_c> * metre
• fix: pow() of a dimension, a quantity specification, or a unit with a negative exponent (e.g., pow<-1>(metre)) failed to compile and now yields the inverted expression
• (!) refactor: a quantity equation keeps a kind per factor. A kind operand becomes a kind factor of the result and a typed operand stays typed. kind_of<isq::length> / isq::duration is now derived_quantity_spec<kind_of_<isq::length>, per<isq::duration>> rather than isq::length / isq::duration, so 42 * m / isq::duration(2 * s) converts implicitly to a child of isq::speed defined over isq::height, which it couldn't before. A result whose factors are all kinds is a kind as before. A kind factor and a typed factor of one tree stay separate, so isq::duration(2 * s) / (1 * s) is a ratio of two durations rather than dimensionless, and still converts to it implicitly
• (!) refactor: inverse() of a dimension, a quantity specification, or a unit is now a hidden friend, like pow(), sqrt(), and cbrt(). An unqualified call works as before, but mp_units::inverse(m) no longer compiles and needs the qualification dropped
• (!) refactor: the std-format-spec helpers that formatters are written against (fmt_align, fill_t, fmt_arg_ref, fill_align_width_format_specs, parse_align, parse_dynamic_spec, parse_fill_align_width, parse_nonnegative_int, handle_dynamic_spec, width_checker, write_padded, at_most_one_of) moved from mp_units::detail to the public mp_units::utility namespace and now ship from mp-units/utility/format.h; mp-units/bits/fmt.h and mp-units/bits/format.h are gone
• feat: C++26 contracts support added (contracts=std Conan option / MP_UNITS_API_CONTRACTS=STD CMake option); experimental, requires GCC 16 with -fcontracts (#682)
• feat: MP_UNITS_PRECONDITION, MP_UNITS_PRECONDITION_DEBUG, MP_UNITS_PRE, MP_UNITS_POST, MP_UNITS_PRE_BODY, and MP_UNITS_PRE_BODY_DEBUG compatibility macros added; MP_UNITS_EXPECTS* are now GSL-backends-only (unchanged there, no-op under C++26 contracts) (#682)
• feat: contracts=std may be combined with import_std (the GSL-era restriction applied only to third-party library headers) (#682)
• feat: contracts=std may be combined with freestanding; the application has to provide a contract-violation handler or compile with an evaluation semantic that does not call one (e.g. quick_enforce) (#682)
• fix: INTMAX_MAX macro replaced with std::numeric_limits<std::intmax_t>::max() in contract predicates (the macro is unavailable with import std;)
• (!) feat: natural units reworked from scratch
• (!) feat: IAU system definition improved
• feat: uncertain<T> representation type added to mp-units::utility (first-order uncertainty propagation for independent values) (#464)
• feat: measured constants may now declare their standard uncertainty in the form their source publishes it (exact metadata on named_constant): standard_uncertainty (absolute, in the constant's own dimension, transcribing the CODATA table row verbatim) or relative_standard_uncertainty (unit-invariant, for constants whose defining unit is not tabulated); MeasuredConstant concept, get_standard_uncertainty, get_relative_standard_uncertainty, and measurement_of added, with each accessor deriving the undeclared form on demand; declared for iau::newtonian_constant_of_gravitation and all measured constants in the three hep CODATA namespaces (#464, #820)
• feat: unit conversion factors built from measured constants carry their relative standard uncertainty; the conversion engine folds it into representation types that opt in via fold_conversion_uncertainty (e.g., uncertain<T>), with measured constants shared by both units canceling symbolically; exact representation types are unaffected (#464)
• feat: uncertain<T> gained the concise output notation of ISO 80000-1:2022, 7.2.4, selected by appending ~ to its format-spec (23.4782(32)); precision states the number of significant digits of the uncertainty (two by default, as published by CODATA), and the value ± σ form remains the default (#464)
• feat: comparisons against literal 0
• feat: hep system refactored to be similar to leading projects in the HEP domain
• feat: hep system extended with new constants and specialized quantities
• feat: unit_for, reference_for, and rep_for added
• feat: linear algebra integrations added (headers mp-units/integrations/{eigen,glm,blaze}.h and modules mp_units.integrations.{eigen,glm,blaze}) so Eigen, GLM, and Blaze vectors and matrices can be used directly as quantity representations
• feat: integration_{eigen,glm,blaze} Conan options / MP_UNITS_BUILD_INTEGRATION_{EIGEN,GLM,BLAZE} CMake options added to skip an integration whose library is installed but does not build with the toolchain in use (#843)
• feat: representation_canonical_type customization point added (materializes expression-template representations before storing them in a quantity)
• feat: quantity character split into two orthogonal axes, quantity_tensor_order (scalar, vector, tensor) and quantity_field (real, complex), so complex vectors and tensors are now expressible
• feat: cartesian_tensor built-in representation type added (fixed 3×3 second-order Cartesian tensor with the ISO 80000-2 second-order operations)
• feat: numeric_field and tensor_order customization points added (adapter-overridable traits that report a representation's field and order)
• feat: type conversions improved to raise compile-time warnings on truncation
• feat: natural_point_origin<QuantitySpec> added (replaces zeroth_point_origin<QuantitySpec>)
• feat: is_natural_point_origin<T> added (replaces is_zeroth_point_origin<T>)
• feat: range-validated quantity points added (the bounds policy of an origin, such as check_in_range or wrap_to_range, is enforced on construction from a value, on unit and origin conversion, and in arithmetic)
• feat: the bounds of a relative origin are checked at compile time to nest within those of its nearest bounded ancestor
• feat: a bounds policy with bool operator()(const V& v) const is a checking policy and one with V operator()(V v) const is an adjusting policy (a value a checking policy rejects goes to constraint_violation_handler<Rep>, and without one it violates the precondition of the operation storing it)
• feat: exclusive_bound{q} added to exclude an end from the range of a bounds policy (accepted by check_in_range at either end and by wrap_to_range at its max)
• feat: each bound of a bounds policy must be exactly representable in the quantity type of a point checked against it, and so must the offset to a bounded ancestor for a point with a representation that is not floating-point
• feat: a point that breaks that rule is not constructible from a quantity and offers no is_within_bounds or try_make (a float point needs float bounds: the double value of 0.1 isn't a float value)
• feat: min() and max() of a point whose origin has no bounds of its own report the bounds of its nearest bounded ancestor in the point's frame (with a floating-point representation, the extreme values those bounds accept after rounding)
• fix: == and <=> between points of different origins are offered only when the translation their bodies perform compiles (a constrained representation has no arithmetic with a plain origin offset)
• feat: the static member functions QP::is_within_bounds(q, origin) and QP::try_make(q, origin) added for points with a checking policy or without bounds (try_make returns std::expected<QP, bounds_violation>)
• feat: quantity_from_unit_zero() member function added (replaces quantity_from_zero())
• feat: numerical_value_in(Unit) and force_numerical_value_in(Unit) member functions added to quantity_point (extract the raw value of a default-origin point; the inverse of point<Unit>(value)) (#813)
• (!) feat: rounding policies (truncated, rounded, rounded_down, rounded_up) added for truncating conversions; passed as the last argument of in(), numerical_value_in(), and value_cast() (#534)
• (!) refactor: force_in() and force_numerical_value_in() deprecated (use in() and numerical_value_in() with a rounding policy, e.g. truncated) (#534)
• (!) fix: truncating conversions by an irrational factor (e.g. rad -> deg) now round negative values towards zero, consistently with the rational-factor conversions (previously they rounded towards negative infinity)
• (!) fix: quantity_point::min()/max() now report a range bound as the point's own quantity type, so a bound declared in a different unit or representation is no longer truncated (e.g. a 1500 * m bound on a km-based point reported 1 km, below the declared minimum)
• feat: fahrenheit_zero point origin added (replaces zeroth_degree_Fahrenheit)
• feat: dimensionless quantities with unit one can now be created with quantity_spec::op(Val) explicit conversions
• feat: explicit construction from number enabled for dimensionless subkinds
• feat: quantity hierarchies improved
• feat: dim_angle text symbol changed to α
• feat: missing unit symbols added for cases where the unit and symbol have the same identifier
• feat: league symbol set to lea
• feat: si2019 namespace made inline
• feat: typographic system extended
• feat: astronomy system added
• feat: explicit quantity_spec conversions added for quantity_point
• (!) refactor: pi magnitude constant renamed to pi_c
• (!) refactor: international system renamed to yard_pound
• (!) refactor: zeroth_point_origin<QuantitySpec> deprecated (use natural_point_origin<QuantitySpec>)
• (!) refactor: is_zeroth_point_origin<T> deprecated (use is_natural_point_origin<T>)
• (!) refactor: quantity_from_zero() deprecated (use quantity_from_unit_zero())
• (!) refactor: zeroth_kelvin deprecated (use absolute_zero)
• (!) refactor: zeroth_degree_Celsius deprecated (use ice_point)
• (!) refactor: zeroth_degree_Fahrenheit deprecated (use fahrenheit_zero)
• (!) refactor: zeroth_rankine deprecated (use si::absolute_zero)
• refactor: CGS <-> SI interop improved with using declarations
• refactor: isq::time swapped with isq::duration
• refactor: deprecation warnings now include the release version
• refactor: representation concepts cleanup
• (!) refactor: the flat quantity_character enumeration (real_scalar, complex_scalar, vector, tensor) deprecated; use the quantity_tensor_order and quantity_field axes
• (!) refactor: representation character derived from intrinsic, adapter-overridable tensor_order and numeric_field traits plus a single disable_representation opt-out (replacing the previous is_* / disable_* flags and the NotQuantity concept)
• refactor: quantity_spec call operator constraints improved
• refactor: quantity_cast constraints improved
• refactor: [[nodiscard]] applied to the constructors of all library value types (quantity, quantity_point, cartesian_vector, cartesian_tensor, polar_vector, spherical_vector, safe_int, constrained, fixed_string, and symbol_text) (#234)
• fix: fixed-point arithmetic for integer unit conversions (#764, based on original work by @burnpanck in #580)
• fix: overflow-safe cross-unit integer comparisons using double-width arithmetic (#766, based on original work by @burnpanck in #580)
• fix: dimensionless quantities truncation prevention fixed
• fix: clang-18 workaround for pragmas not working in a C++ module build
• fix: normal_stress and shear_stress fixed to have stress as a parent
• fix: mechanical_energy requires a very generic equation that overrides the one from mechanical_work
• fix: fathom definition fixed and moved to yard_pound system
• fix: quantity_cast support fixed for quantity_point
• fix: quantity::magnitude() extended to tensor quantities and complex fields (Hermitian and Frobenius norms); vector decomposition (get) now works for complex vectors
• test: multiply syntax unit tests added
• test: gravitational_potential_energy definition updated to match ISQ
• test: fathom test moved to yard_pound
• build: deprecation comments added to CMake file for format.h and ostream.h
• ci: build_policy and CI detection support added to check_all.sh
• ci: environment tests moved to validate_environment.sh script
• ci: CI build matrix generated dynamically from a Python script (#767, based on original work by @burnpanck in #637)
• ci: toolchain feature support thresholds derived from conanfile.py via AST to eliminate duplication between the Python script and the Conan recipe
• ci: generate-matrix-summary.py added to write a Markdown build matrix table and per-value coverage statistics to GITHUB_STEP_SUMMARY
• chore: site/ subdirectory added to .gitignore
• chore: persistency for conan and pipx packages added to devcontainer
• docs: systems reference documentation generator added
• docs: HEP system description added
• docs: "Safety Features" chapter added
• docs: "Yard-Pound Systems" chapter added
• docs: IAU and astronomy systems documentation added
• docs: ISQ, SI, and CGS systems documentation added
• docs: "Using Custom Representation Types" chapter added
• docs: "Character of a Quantity" chapter updated for the two-axis (order and field) model
• docs: "Pure Dimensional Analysis" chapter added
• docs: How-to Guides improved
• docs: "Creating distinct quantity kinds with is_kind" chapter added
• docs: "Strongly-Typed Counts" workshop added
• docs: incremental migration workshop added
• docs: workshops restructured into subdirectories
• docs: "New Systems Documentation Generator" blog post added
• docs: interactive learning blog post added
• docs: quantity hierarchies added to User's Guide
• docs: multiple new workshops added (tutorials 9–12)
• docs: "Type Safety in Practice" chapter updated
• docs: IEC 80000 renamed to IEC in documentation
• docs: "Use Cases" renamed to "How-to Guides"
• docs: "Obtaining Metadata" renamed to "Type Introspection"
• docs: documentation TOC restructured
• docs: total_energy example added
• docs: "AI-Generated Contributions" chapter added to CONTRIBUTING

2.5.0 December 24, 2025

• (!) feat: representation concepts improved
• (!) feat: representation_of concept now also accepts a quantity_spec and accepts any representation character for quantity kinds
• (!) feat: quantity::one() removed
• (!) feat: Representation concept removed
• feat: SymbolicArg applied to expression templates
• feat: per and power made final
• feat: derived_XXX are now constrained with SymbolicConstant
• feat: prime factorization extended to any magnitude (thanks @chiphogg)
• feat: cartesian_vector added
• feat: equivalent now accept any units (even non-convertible)
• feat: text output should fallback to the portable mode when UTF-8 is not used for text_encoding
• feat: precondition added to to_u8string
• feat: text output of scaled units is now enclosed in parenthesis (...) instead of brackets [...]
• feat: abs(quantity) exposed for conforming freestanding implementations
• feat: proper constraints for kind_of
• feat: missing precondition added for quantity::op/
• feat: quantity_spec conversions improved
• feat: rankine unit added
• feat: std::numeric_limits support added
• feat: scaling_overflows_non_zero_values added to detect conversions overflowing rep
• feat: deprecation messages now provide the release version where the deprecation happened
• feat: electromagnetism.h updated to IEC80000-6-2022 with raw numbers
• feat: lerp and midpoint for points added
• feat: is_value_preserving customization point added
• feat: EQUIV{...} replaced with [...] in the text output of common units
• feat: constexpr_format added
• feat: unsatisfied added and enabled throwing constraints
• feat: some constraints refactored to throw exceptions with nice error messages
• feat: explicit constructor now can perform an explicit quantity_spec conversion
• feat: natural units support is now opt-in
• feat: value_type_t is now recursive
• feat: support for root of negative numbers removed
• feat: old MSVC workarounds disabled for the latest version
• feat: invoke_with_prefixed added to SI
• feat: QuantityLike should not satisfy the Representation concept
• feat(example): is_vector specialization no longer needed for si_constants
• feat(example): measurement.h extracted for easier reuse
• feat(example): clcpp_response and conversion_factor examples removed
• (!) refactor: type_list moved to implementation details
• (!) refactor: from now unit_symbol and dimension_symbol always returns std::string_view
• (!) refactor: text_encoding renamed to character_set
• (!) refactor: Magnitude renamed to UnitMagnitude and magnitude to unit_magnitude
• (!) refactor: unit_magnitude moved to detail namespace
• (!) refactor: absolute renamed to point
• (!) refactor: power members refactored to be explicitly exposition only
• (!) refactor: is_XXX customization points for representation types removed
• (!) refactor: quantity_values renamed to representation values
• (!) refactor: scalar and complex characters renamed to real_scalar and complex_scalar respectively + concepts refactoring
• (!) refactor: MagConstant concept renamed to detail::is_mag_constant variable trait
• (!) refactor: format.h header file made deprecated
• (!) refactor: ostream.h header file made deprecated
• (!) refactor: rename default_denominator to default_solidus in unit_symbol_solidus enum
• refactor: mp_units.core defined in terms of core.h
• refactor: MP_UNITS_NONCONST_TYPE introduced to benefit from the C++23 feature
• refactor: SymbolicConstant concept refactored
• refactor: explicit type of op/ for quantity and reference replaced with constrained placeholder
• refactor: private unit_magnitude interface renamed to not use leading _
• refactor: one_of concept removed and replaced with QSProperty in quantity_spec
• refactor: std::is_trivial will be deprecated in C++26
• refactor: SameQuantitySpec concept removed and replaced with direct comparison
• refactor: unused SameReference concept removed
• refactor: type_name_less introduced and used as a default predicate for expression templates
• refactor: "expression templates" renamed to "symbolic expressions"
• refactor: all_are_kinds removed and get_associated_quantity simplified
• refactor: reference now returns explicit types for inverse, pow, sqrt, and cbrt
• refactor: repeated concept checks removed from get_common_reference
• refactor: std::assignable_from used in ValuePreservingTo concept
• refactor: quantity constructor refactored to use another constructor with the result of sudo_cast
• refactor: preconditions for quantity operations now use is_neq_zero
• refactor: implicit expression variations used in quantity and quantity_point constraints
• refactor: inverse() constraints improved
• refactor: make_quantity_point introduced
• refactor: point_origin_interface::op+ return type unified with the rest of the interfaces
• refactor: std::convertible_to replaced with std::same_as in basic_fixed_string
• refactor: less, ceil, and round refactored and improved + more unit tests for round
• refactor: math_concepts.h removed and concepts replaced with explicit expression in constraints
• refactor: visit_format_arg is deprecated in C++26
• refactor: deprecated literal operators
• refactor: constraints refactoring
• refactor: compund assignment and pre-/post-increment operators are now lvalue-qualified member functions
• refactor: ValuePreservingScaling concepts renamed
• refactor: common_type specializations refactored
• refactor: NumberLike renamed to DimensionlessOne
• refactor: branching on a deprecated C++ feature improved
• refactor: all CTADs made implicit
• refactor: MP_UNITS_REMOVE_CONST gcc workaround added to RepresentationOf
• refactor: ReferenceOf concept simplified
• refactor: explicitly defaulted special member functions removed
• refactor(example): slight refactoring of examples while working on their documentation
• refactor(example): kalman filter examples refactored to better match their
• refactor(example): is_hae function refactored to HAEAltitude concept
• (!) fix: electric_current_phasor, voltage_phasor, apparent_power switched to complex character
• (!) fix: position_vector and displacement moved to a different place in a tree
• (!) fix: velocity is now defined in terms of displacement instead of position_vector
• fix: missing core.h added to CMake
• fix: const was leaking to some SymbolicConstants
• fix: make_reference should skip only the exact kinds deduced from a unit
• fix: inconsistencies in get_common_quantity_spec() fixed
• fix: unused convertible_kinds() argument removed
• fix: compile-time branch condition fixed in quantity_point::point_for
• fix: inverse(Quantity) fixed for subkinds of dimensionless
• fix: point_origin_interface::op+ constraints fixed
• fix: missing get_common_unit() overload added
• fix: floor and ceil constraints fixed
• fix: quantity characters fixed in electromagnetism quantities
• fix: arg.visit support fixed
• fix: expr_less now also sorts powers
• fix: mag_constant workarounds branches for clang fixed
• fix: checking for clang versions fixed in CMake scripts
• fix: text stripping in type_name fixed
• fix: make quantity conversion to Rep constexpr (thanks @KangarooKoala)
• fix: MSVC compilation fixed
• fix: abs interface and implementation improved
• fix: unused parameters removed from scaling_overflows_non_zero_values
• fix: invalid precondition check in root removed
• fix: workaround for fmt
• fix: CTAD issue workaround for MSVC
• fix: dynamic_spec_id_handler fixed for gcc-15
• fix: MSVC workarounds for consteval functions
• fix: resolve CMake compiler test failure in freestanding CI builds (thanks @rothmichaels)
• fix: msvc empty bases workaround (thanks @Radnyx)
• fix: seconds literal has unspecified type and depends on implementation (thanks @Radnyx)
• fix: named_unit can now be created for kind_of<dimensionless>
• fix: enable runtime usage of inverse function by using compile-time unit extraction (thanks @rothmichaels)
• fix: CTAD for dimensionless quantities fixed
• fix: concepts tests compilation fixed for MP_UNITS_API_NATURAL_UNITS OFF
• fix: missing natural units support added to package_info()
• fix: freestanding build error in Conan package_info() (thanks @kammce)
• fix: replace wstring_view with basic_string_view<wchar_t> (thanks @kammce)
• Fix destination unit creation in inverse
• fix(docs): typo in a file name fixed
• fix(example): text formatting fixed for glide_computer documentation
• test: lots of tests for complex quantities
• test: runtime unit tests refactored to have a bigger granularity (less top level tests)
• test: surface tension replaced with entropy in an fmt test
• test: test_package now is tested also with C++20 modules
• test: tests for dimensionless quantities static data members
• test: a few more natural units tests added
• test: tests to check if quantity satisfies Scalar
• test: add static tests for concept DimensionOf (thanks @jvocht)
• test: quantity character concepts tests for quantities added
• test: duplicated dimensionless tests removed
• test: additional concepts tests for quantity spec added
• docs: ISQ part 6 released
• docs: new chapter about our documentation added to the contributing guide
• docs: directory name updated in the contributing guide
• docs: mp-units Conan options added to conanfile.txt examples
• docs: contracts Conan option default value description improved
• docs: outdated note removed from the "Text Output" chapter
• docs: a paragraph about additional formatting options removed (applicable only to quantity symbols which we do not support)
• docs: Wrocław 2024 meeting report
• docs: explicit unit conversion example added to the "Symbols of common units" chapter
• docs: "Bringing Quantity-Safety To The Next Level" blog post added
• docs: quantity-safety mentioned in the docs
• docs: complex character added to the "Quantity character" chapter
• docs: intro to "Value Conversions" chapter added
• docs: "Scaling overflow prevention" chapter added
• docs: "Concepts" chapter updated
• docs: old customization points removed from the "Character of a Quantity" chapter
• docs: clang-19 issues mentioned in a compiler support table
• docs: "Introducing absolute quantities" blog post added
• docs: relative path removed from the contributing guide
• docs: examples updated and deprecated tags generation replaced with modern usage
• docs: compiler explorer links replaced with buttons
• docs: "Installation and Usage" cleanup
• docs: "Introduction" chapter improved
• docs: "Quick Start" Improved
• docs: "Interface Introduction" improved
• docs: "Systems of Quantities" chapter improved
• docs: "Concepts" chapter improved
• docs: README updated
• docs: "Install as a Dependency" added to README
• docs: tutorials section added
• docs: info about kind_of<dimensionless> units added
• docs: adjust formatting in temperature printing function for better alignment
• docs: README visually improved
• docs: 2 new chapters added to README
• docs: link to mp-units in ConanCenter added to README
• docs: "Support the Project" added to README
• docs: enhance testimonials section for clarity and inclusivity
• docs: clarify flowchart labels for quantity addition and differences
• docs: CONTRIBUTORS.md added
• docs: examples reworked
• docs: "Cheat Sheet" added
• docs: "Auto-scaling of a quantity" chapter added
• docs(ref): document most of mp_units.core (thanks @JohelEGP)
• build: CheckCacheVarValues CMake module file added
• build: MP_UNITS_DEV_TIME_TRACE CMake option added
• build: MP_UNITS_API_NO_CRTP removed from test_package CMake
• build: require at least CMake 3.31 with Conan
• build: clang-20 enabled in CI
• build: clang-19 support removed from conanfile.py
• build: clang-20.1 workaround added to package_info
• build: update dependencies to gsl-lite/1.0.1, ms-gsl/4.2.0, fmt/12.1.0, catch2/3.11.0, cmake/4.2.1
• build: suppress warnings for gcc-12 in conanfile
• build: switch freestanding CI to clang-20
• build: gcc installation step is now mandatory for all gcc versions
• build: import_std set to False by default
• build: wg21-linear_algebra dependency removed
• build: check_libcxx_in_use improved
• build: Gitpod support removed
• build: CodeSpaces support added
• build: CMake switched to a new gsl-lite target
• build: clang-21 added to check_all.sh
• build: gcc-15 enabled in check_all.sh
• build: explicit_this enabled for AppleClang 17 and MSVC 19.32 (thanks @alex-tee)
• build: add build: add INSTALL option to cmake option to cmake (thanks @alex-tee)
• build: projectPrefix CMake variable removed
• build: MP_UNITS_BUILD_AS_SYSTEM_HEADERS removed
• build: warnings.cmake refactored to use CMAKE_COMPILE_WARNING_AS_ERROR
• build: CMAKE_COMPILE_WARNING_AS_ERROR set in conanfile
• build: PROJECT_IS_TOP_LEVEL used in ensure_entry_point
• build: Various cleanup (thanks @HazardyKnusperkeks)
• build: CMake config file variables handling fixed
• build: dereferencing CMake variables in if() conditions is not needed
• build: improved setting of MP_UNITS_BUILD_CXX_MODULES for test_package
• build: MP_UNITS_BUILD_CXX_MODULES will now be always provided by Conan
• build: CMake CI should run the cmake executable provided by Conan
• build: C++23 enabled for test_package when import std is ON
• build: all target_compile_definitions aggregated in one place
• ci: CI matrix generation added (thanks @burnpanck)
• ci: import_std now checks if at least C++23 is being used
• ci: GitHub actions improved
• ci: dependency review GitHub action added
• ci: clang-21 support added
• ci: update dependency review configuration
• ci: housekeeping after release step fixed in ci-conan
• ci: the macOS-13 based runner images are retired in GitHub
• ci: old 'VISUAL' decendant of Conan 1.x removed from CMake CI
• perf: caching of the results of heavy consteval functions execution added
• perf: expr_projectable concept removed to improve compilation performance
• style: pre-commit tools updated
• style: markdownlint rules updated
• style: MD036 added to .markdownlint.json
• chore: add issue templates for bug reports, documentation issues, and feature requests
• chore: add usage experience issue template and a chapter in README
• chore: PR template added
• chore: FUNDING.yml file added

2.4.0 November 5, 2024

• (!) feat: phase_velocity and group_velocity aliases removed from ISQ by ISO
• feat: iec::bit using-declared in iec::unit_symbols
• feat: common unit symbols now use EQUIV{u1, u2, ...} syntax
• feat: scaled_unit symbol printing improved ([] around the entire unit, small magnitude values do not use a power of 10 anymore)
• feat: scaled_unit does not have a priority over derived_unit anymore
• feat: fractional exponents support added to mag_power
• feat: tag types are now required to be empty
• feat: magnitude text now obeys formatting parameters and knows how to print constants
• feat: added support for printing powers of magnitude constants
• feat: SymbolicConstant concept added
• feat: common_unit selection algorithm improved to make rev + rad return rad
• feat: litre text symbol changed from l to L to avoid ambiguity with 1
• feat: alternative litre unit symbol L added to prevent ambiguities with 1
• feat: Unicode unit symbols
• feat: π added as an alias for pi
• feat: expr_pow extended to remove redundancy in callers
• feat: DerivedDimensionExpr, DerivedQuantitySpecExpr and DerivedUnitExpr removed
• feat: MagnitudeSpecExpr and PowerVBase removed and some functions renamed to limit possible ambiguity in overload resolution
• feat: std::is_object constraint applied to value_type_t
• feat: quantity_values are now defined on top of std::chrono::duration_values
• feat: from now on truncation is not allowed in compound assignment
• feat(example): currency example now uses chrono::time_point and has better interfaces
• feat(example): treat_as_floating_point specializations for examples' types removed
• (!) refactor: all iec quantity specifications are now deprecated and moved to isq
• (!) refactor: mag_constant now takes a symbol and a value and the class deriving from it must be final
• (!) refactor: op==(U1, U2) now checks for the same type (old behavior available as equivalent(U1, U2)) + convertible now verifies associated quantity_spec as well
• (!) refactor: ascii -> portable, unicode -> utf8, 'A' -> 'P'
• (!) refactor: char_traits removed from fixed_string
• (!) refactor: convertibility traits and concepts refactored to use bool flags instead of wrappers
• (!) refactor: tag types should not expose their members
• refactor: convertible(U1, U2) implementation simplified
• refactor: abs moved to constexpr_math.h
• refactor: unit_symbol_impl simplified
• refactor: unit_symbol_formatting moved to a dedicated header file
• refactor: shorten_T removed
• refactor: magnitude interface cleanup
• refactor: derived_from_the_same_base_dimension no longer needed
• refactor: one_of usage removed from the fixed_string deduction guides
• refactor: quantity.h is not needed in constants.h (unit.h is enough)
• refactor: SameDimension concept is not needed and can be inlined in DimensionOf
• refactor: framework Unicode symbols are now spelled using their codes
• refactor: QuantitySpecWithNoSpecifiers removed and kind_of definition simplified
• refactor: treat_as_floating_point simplified and extended to use std::chrono::treat_as_floating_point_v
• refactor: wrapped_type_t reuses std::indirectly_readable_traits
• refactor: expr_fractions takes direct OneType type now instead of a trait
• refactor: Unicode symbols description reworked based on the latest SG16 recommendations
• refactor: Mutable concept applied to quantity and quantity_point
• refactor: explicit cleanup for deduction guides of quantity and quantity_point
• refactor: point_origin_interface::op- cleanup
• refactor: QuantityLikeImpl refactored to conform to API Reference by @JohelEGP
• refactor: get_complexity refactored to be 0-based and not account for a number of arguments in a list
• refactor: get_complexity refactored to returned maximum complexity of an element (instead of the sum of elements)
• refactor(test): derived_quantity refactored to child_quantity
• fix: missing are_ingredients_convertible overloads added
• fix: constraints for magnitude added for scaled_unit and fixed common_unit instantiating it incorrectly
• fix: according to ISO 80000-16 % should always be prefixed with space
• fix: extraneous space in unit symbol having only denominators removed
• fix: explicit cast added to less for magnitudes to fix clang-arm64 conversion error
• fix: common_unit handling fixed for some corner cases
• fix: math functions constraints fixed
• fix: operator*(M, U u) fixed for U being scaled_unit
• fix: subsumption of QuantityKindSpec fixed
• fix: ValuePreservingTo fixed to apply std::remove_cvref_t on FromRep
• fix: compound assignment operations on quantities now behave the same as on the underlying representation types
• fix: QuantityConvertibleTo used in quantity_point compound assignment
• fix: convertible_kinds implementation fixed
• fix(tests): freestanding build fixed
• test: unit tests for the inverse of mag_constant added
• test: Unicode symbols used in unit tests
• test: more std::chrono tests added
• test: commutativity tests added to ISQ
• test: one kind_of test added to reference tests
• test: pow<0> and pow<1> tests added for dimensions
• test: more get_common_quantity_spec tests added
• build: setting of some test_package CMake options enabled only for a cxx_modules build
• ci: sudo apt update added for documentation.yml in hope that it will resolve missing system packages issue
• ci: MSVC added to the CI
• ci: the latest not-released docs will use "HEAD" as a version from now on
• ci: documentation action should run on a new tag as well
• ci: documentation action limited only to commits that change documentation files
• ci: non-documentation actions should not run on tags
• docs: missing systems added to the "Project Structure" chapter
• docs: graphs of ISQ kind hierarchies improved
• docs: category of the ISO meeting reports changed to "WG21 Updates"
• docs: blog comments support added
• docs: Part 1-5 articles of the ISQ series added
• docs: "Symbols of scaled units" chapter added + minor updates to scaled and common units chapters
• docs: conan profile updated to present gcc-14 instead of gcc-12 which is no longer supported
• docs: "Why derived units order is not preserved from the multiplication?" chapter added to FAQ
• docs: "Many shades of the same unit" extended with a note about the derived units order
• docs: API Reference now presents index.html instead of full.hml

2.3.0 September 27, 2024

• (!) feat: delta and absolute construction helpers
• (!) feat: Conan and CMake options changed as requested at ConanCenter code review
• (!) feat: unit_can_be_prefixed removed - from now on all named units can be prefixed
• feat: formatting functions for units and dimensions marked as constexpr to enable compile-time text formatting
• feat: qp1.quantity_from(qp2) added
• feat: non-member swap added for fixed_string
• feat: simplified inplace_vector added
• feat: text output for angular units improved (space before symbol removed)
• feat: representation type template parameter added to value conversion functions
• feat: all tags in the expression templates are now ordered by the type names
• feat: convertibility of a quantity with a unit one with the raw value added
• feat: import std; support added
• feat: compute values for rational magnitude powers (thanks @chiphogg)
• feat: value_cast<Representation, Unit>() complementary conversion function added
• feat: hw_voltage example added
• feat: MP_UNITS_IMPORT_STD and MP_UNITS_MODULES handled properly in test_package.cpp
• feat: complex quantity character added
• feat: iec::var unit added
• feat: type_list_unique added
• feat: for_each on std::tuple added
• feat: common_unit support added
• (!) refactor: quantity_point_like_traits now use numerical value instead of the quantity
• (!) refactor: iec80000 system renamed to iec
• (!) refactor: mag_pi is now mag<pi>
• (!) refactor: common_XXX() functions renamed to get_common_XXX()
• refactor: error messages-related improvements
• refactor: [[nodiscard]] and consteval set for some magnitude-related functions
• refactor: degree Celsius and Fahrenheit symbols text now use Unicode codepoints
• refactor: dimension_symbol and units_symbol refactored to use inplace_vector
• refactor: unit_symbol and dimension_symbol refactored for readability and consteval
• refactor: binary operators of quantity and quantity_point are now hidden friends
• refactor: tag types-related operators are now hidden friends as well
• refactor: ValuePreservingTo concept added
• refactor: perfect forwarding interfaces improved
• refactor: Representation concepts now requires WeaklyRegular instead of std::regular
• refactor: quantity_point default-constructibility removed from the quantity_from constraints
• refactor: has_common_type_v simplified
• refactor: is_power_of_quantity_spec and is_power_of_dim variable templates converted to concepts
• refactor: unnecessary custom versions of is_specialization_of removed
• refactor: is_derived_from_specialization_of_v added and applied to remove custom traits
• fix: signatures of capacity functions of fixed_string fixed
• fix: MP_UNITS_API_NO_CRTP handling fixed
• fix: MP_UNITS_HOSTED branch added to core.h
• fix: mkdocs dependencies fixed in the gitpod dockerfile
• fix: MP_UNITS_API_CONTRACTS should have a priority over headers availability
• fix: si.h and angular.h now properly include hacks.h to define MP_UNITS_HOSTED before its usage
• fix: quantity scaling between different prefixes improved
• fix: conversion operator to std::chrono types fixed
• fix: std::format does not always use Char* as iterators
• fix: complex_power & co fixed
• fix: __cpp_deleted_function workaround for clang-19 added
• test: conversion to chrono unit tests added
• test: unit tests for creating a quantity from a volatile variable
• test: increase tolerance for certain math tests to two epsilon by @burnpanck
• test: std::complex-based quantities tests added
• build: conanfile bumped to use catch2/3.7.0
• build: conanfile bumped to use fmt/11.0.1
• build: minimum required CMake version bumped to 3.25
• build: duplicated cmake_minimum_required commands removed
• build: minimum conan version set to 2.0.15
• build: MSVC compilation enabled for the library part by @czjhoppe
• build: Dockerfile updated for gitpod
• build: generate() in test_package now correctly propagates project's options
• build: target_include_directories is not needed anymore
• build: target_compile_features now uses CMAKE_CXX_STANDARD
• build: package_type is dynamically set in conanfile.py depending if we build modules or not
• build(conan): packaging improved
• ci: added test for upstream clang on macos-14, as an example for an arm64 platform by @burnpanck
• style: pre-commit updated to clang-format-18.1.8
• docs: "Strong Angular System" chapter added
• docs: docs updated to use new spelling for Conan options
• docs: "Interface Introduction" chapter updated
• docs: St. Louis 2024 report added
• docs: "Radians and degrees support" added
• docs: Rework of "Getting Started" section
• docs: "API Reference" support added (thanks @JohelEGP)
• docs: "Generating API reference" chapter added
• docs: minor formatting and spelling improvements to the "CONTRIBUTING.md"
• docs: "Unit symbols" chapter added
• docs: examples line numbers fixed
• docs: "Text Formatting" tag removed from avg_speed example
• docs: line breaks in mermaid graphs fixed
• docs: 2.3.0 release added

2.2.1 July 3, 2024

• (!) feat: Conan and CMake options refactored

2.2.0 June 14, 2024

• (!) feat: C++ modules support added by @JohelEGP
• (!) feat: New formatting specification implemented
• (!) feat: has_unit_symbol support removed
• (!) feat: ABI concerns resolved with introduction of u8 strings for symbols
• (!) feat: API-related Conan, CMake, and preprocessor options redesigned
• (!) feat: core.h removed
• (!) feat: from now on units, dimensions, quantity specifications, and point origins have to be marked as final
• feat: implicit point origins support added
• feat: unit default point origin support added
• feat: fma, isfinite, isinf, and isnan math function added by @NAThompson
• feat: fma for quantity points added
• feat: quantity_point support added for quantity_cast and value_cast
• feat: value_cast<Unit, Representation> added
• feat: value_cast<Quantity>(q), value_cast<Quantity>(qp) and value_cast<QuantityPoint>(qp) added by @burnpanck
• feat: interconvertible(quantity_spec, quantity_spec) added
• feat: qp.quantity_from_zero() added
• feat: value_type type trait added
• feat: do not print space between a number and percent or per_mille
• feat: ppm parts per million added by @nebkat
• feat: atan2 2-argument arctangent added by @nebkat
• feat: fmod floating-point division remainder added by @nebkat
• feat: remainder IEEE division remainder added by @nebkat
• feat: std::format support added
• feat: unit text output support added
• feat: formatting error messages improved
• feat: improve types readability by eliminating extraneous () in references, prefixes, and kind_of
• feat: dimension and unit text output added
• feat: some light and radiation ISQ quantities added
• feat: allow configuring GSL library use
• feat: freestanding support added
• (!) refactor: zero_Fahrenheit renamed to zeroth_degree_Fahrenheit
• (!) refactor: SI-related trigonometric functions moved to the si subnamespace
• (!) refactor: math.h header file broke up to smaller pieces
• (!) refactor: fixed_string interface refactored
• (!) refactor: ReferenceOf does not take a dimension anymore
• (!) refactor: 'o' replaced with '1' as a modifier for unit_symbol_solidus::one_denominator
• (!) refactor: get_kind() now returns kind_of
• (!) refactor: FMT macros moved to compat_macros.h
• (!) refactor: fixed_string refactored to reflect the latest changes to P3094R2
• (!) refactor: basic_symbol_text renamed to symbol_text
• (!) refactor: ratio hidden as an implementation detail behind mag_ratio
• (!) refactor: framework.h introduced
• (!) refactor: type list tools made an implementation detail of the library
• (!) refactor: header files with the entire system definitions moved up in the directory tree
• (!) refactor: absolute_point_origin does not use CRTP anymore
• refactor: system's units do not inherit from one another anymore
• refactor: all units made final
• refactor: math functions constraints refactored
• refactor: si_quantities.h added to improve compile-times
• refactor: validate_ascii_string refactored to is_basic_literal_character_set
• refactor: underlying_type split to wrapped_type and value_type and used in code
• refactor: code refactored to comply with clang-tidy
• refactor: remove dependency on <ranges> header and switch to use an iterator-based copy algorithm
• refactor: terminate replaced with abort and a header file added
• refactor: most std::remove_const_t removed and some replaced with the GCC-specific workaround
• refactor: not needed remove_reference_t and remove_cvref_t removed
• refactor: binary operators of quantity and quantity_point are now hidden friends
• fix: QuantityLike conversions required Q::rep instead of using one provided by quantity_like_traits
• fix: quantity_spec[Unit] replaced with make_reference in value_cast
• fix: ice_point is now defined with the integral offset from absolute_zero
• fix: performance regression in sudo_cast fixed
• fix: explicit object parameter support fixed
• fix: missing version header file added to hacks.h
• fix: quantity_cast to accept lvalue references (thanks @burnpanck)
• fix: value_cast with lvalue references to quantity_point (thanks @burnpanck)
• docs: project blog and first posts added
• docs: project documentation layout refactored
• docs: "Interoperability with Other Libraries" chapter added
• docs: "Framework Basics" chapters updated and cleaned up
• docs: smoot unit example added to the main page
• docs: "Code Example" chapter renamed to "Look and Feel" and reordered in TOC to be after "Quick Start"
• docs: "Quick Start" chapter reworked to be simpler and include quantity points
• docs: "Quantity points" chapter extended
• docs: "The Affine Space" chapter updated to reflect the recent design changes
• docs: "Working with Legacy interfaces" chapter added
• docs: "Text Output" chapter updated
• docs: mkdocs social plugin enabled
• docs: project logo and custom color scheme added
• docs: minimum compiler requirements updated
• docs: unit symbols admonition extended in the "Quick Start" chapter
• docs: Cairo dependency described in the MkDocs section
• docs: "hello units" example updated with dimensions output
• docs: "Text Output" chapter updated with the recent formatting changes
• docs: formatting grammar language changed to EBNF
• docs: "Project structure" chapter expanded
• docs: CITATION.cff updated
• (!) build: Conan and CMake options refactored
• (!) build: MP_UNITS_AS_SYSTEM_HEADERS renamed to MP_UNITS_BUILD_AS_SYSTEM_HEADERS
• (!) build: MP_UNITS_BUILD_LA and MP_UNITS_IWYU CMake options now have _DEV_ in the name
• build: gsl-lite updated to 0.41.0
• build: catch2 updated to 3.5.1
• build: fmt updated to 10.2.1
• build: gitpod environment updated
• build: check_cxx_feature_supported added
• build: IWYU path handling fixed
• build: IWYU enabled on GCC
• build: CMAKE_EXPORT_COMPILE_COMMANDS flag enabled for the developer's build
• build(conan): generate() now set cache_variables
• build(conan): can_run check added before running tests
• ci: Conan and CMake CI now use different cache names
• ci: gcc-14 added
• ci: clang-tidy CI added

2.1.1 May 16, 2024

• fix: unit tests compilation on gcc-14 fixed
• fix: explicit this parameter support fixed

2.1.0 December 9, 2023

• (!) feat: inverse() support added for dimensions, quantity_spec, units, and references (1 / s will now create quantity and not a Unit)
• (!) feat: quantity_point does not provide zero() anymore
• (!) feat: quantity_spec and its kind should not compare equal
• (!) feat: mutating interface removed from fixed_string
• (!) feat: common_type with a raw value is not needed anymore as for a long time now raw values are not convertible to the dimensionless quantities
• (!) feat: symbol_text definition simplified
• (!) feat: users are now allowed to inherit their own types from absolute point origins
• (!) feat: interoperability with other libraries redesigned
• feat: basic_fixed_string(const CharT*, std::integral_constant<std::size_t, N>) constructor added
• feat: isq::activity added and becquerel definition updated to benefit from it
• feat: gray and sievert now have correct associated quantity kinds
• feat: UnitCompatibleWith concept added and applied to in(U) and force_in(U) functions
• feat: quantities can now be multiplied and divided by units (no parenthesis needed anymore)
• feat: Magnitude / Unit operator added
• feat: equality for dimensions now will allow derived classes as well (but not from derived_dimension)
• feat: zero_Fahrenheit point origin added
• feat: equivalent point origins handling improved
• feat(example): unit symbols added to the currency example
• (!) refactor: unit_symbol<fmt>(U) signature refactored and the resulting text can now also be used at runtime
• (!) refactor: make_xxx factory functions replaced with two-parameter constructors
• (!) refactor: unit_symbol changed to consteval
• refactor: in(U) and force_in(U) now return auto to provide better diagnostics on clang
• refactor: quantity operators constraints refactored
• refactor: more type members added to fixed_string definition
• refactor: unit_symbol_formatting enums now use std::int8_t as a representation type
• fix: symbols of named dimensionless units with the ratio = 1 were not printed
• fix: iterator is now properly updated for all cases in unit_symbol
• fix: Fahrenheit conversion ratio was inverted
• fix: CommonlyInvocableQuantities was overconstrained for the current library design
• fix: are_ingredients_convertible now mandates explicit conversion for To dimensionless quantities
• fix: quantity_point::point_for(PO) constraints fixed
• fix(example): latitude and longitude fixed to include 0 for N and E respectively
• ci: clang-17 enabled
• ci: apple-clang-15 enabled
• ci: Added C++23 builds to the CI matrix
• docs: "Getting Started" chapters updated
• docs: "Basic Concepts" and "Interface Introduction" chapters updated
• docs: "Design Overview" chapter added and "Concepts" chapter reworked
• docs: "Output stream formatting" chapter updated
• docs: "Default formatting" chapter updated
• docs: "Derived unit symbols generation" chapter added
• docs: outdated affine space chapter updated
• docs: CameCase concept identifiers FAQ added
• docs: gravitational_potential_energy equation fixed on a graph
• docs: YouTube video link updated to the C++ on Sea 2023
• docs: ISO papers reference added to docs and README
• docs: a representation type in a dimensionless quantity FAQ fixed
• docs: titles added to some important admonitions
• docs: "Terms and Definitions" slightly updated
• docs: "canonical unit" added to glossary and its documentation in code was updated
• docs: Design overview graph updated

2.0.0 September 24, 2023

• units namespace renamed to mp_units (#317)
• header files in the <mp-units/...> rather then in <units/...> (#317)
• the downcasting facility is removed (#383, #211, #32)
• unified and simplified quantity creation (#274)
• determining the best way to create a quantity (#413)
• V2 quantity_point (#414)
• introduction of quantity_spec to store not only dimension but also additional information about quantities (#405)
• quantity now takes reference object, which aggregates quantity_spec and a unit and a representation type
• units, prefixes, dimensions, quantity specifications, and references are passed as NTTPs to templates and provide arithmetic operations and comparison
• expression templates consistently used in all derived types to increase the readability (#351, #166)
• derived dimensions are now factors of only base dimensions (#281)
• convertibility of derived quantities (#427)
• dimensions, quantity specifications, units, and references are now composable, significantly reducing the number of definitions and resulting types
• heavily simplified unit systems definitions (no need to define unnamed derived units, systems-specific dimensions, aliases for quantities, concepts, UDLs, ... anymore)
• improved definition of all systems
• support for ISO 80000 Part 3-6 quantities
• faster than lightspeed constants (#169)
• extensions to quantity formatting with fmt
• quantity_kind removed
• improved casting of unit with .in(Unit), .force_in(Unit) for quantity and quantity_spec
• numerical value accessor safety improved with .numerical_value_in(Unit) and .force_numerical_value_in(Unit)
• quantity can no longer be constructed with a raw value (#434)
• Implicit construction of quantities from a value (#410)
• quantity_point can no longer be constructed with just a quantity and an explicit PointOrigin is always needed
• ceil and floor are dangerous (#432)
• quecto, ronto, ronna, quetta new SI prefixes support
• comparison against zero added (#487)
• documentation rewritten from scratch
• many smaller changes not possible to address with the previous design (#205, #210, #134)

0.8.0 June 14, 2023

• (!) refactor: common_quantity, common_quantity_for, common_quantity_point, common_quantity_kind, and common_quantity_point_kind removed
• (!) refactor: named_derived_unit removed as it was not used
• (!) refactor: derived_unit renamed to derived_scaled_unit
• (!) refactor: unit renamed to derived_unit
• (!) refactor: U::is_named removed from the unit types and replaced with NamedUnit concept
• (!) refactor: PrefixFamily support removed
• (!) refactor: mi(naut) renamed to nmi
• (!) refactor: knot unit helper renamed to kn in FPS
• (!) refactor: knot text symbol changed from "knot" to "kn"
• refactor: quantity op+() and op-() reimplemented in terms of reference rather then quantity types
• refactor(example): glide_computer now use dimensionless quantities with ranged_representation as rep
• feat: HEP system support added (thanks @RalphSteinhagen)
• feat: floor(), ceil(), and round() support added (thanks @hofbi)
• feat: std::format support for compliant compilers added
• feat: conversion helpers from mp-units to std::chrono types added
• feat: math functions can now be safely used with user-defined types
• feat: conversion from quantity_point to std::chrono::time_point added
• feat: nautical_mile_per_hour and knot added to si::international system
• (!) fix: add quantity_point::origin, like std::chrono::time_point::clock
• fix: enable any prefixes for most of the named units (beside those that use prefixes already)
• fix: hectare definition fixed to be a prefixed version of are + other units
• fix: account for different dimensions in quantity_point_cast's constraint
• fix: output stream operator now properly handles state
• fix: fmt algorithms were overconstrained with forward_iterator
• fix: CTAD for aliases fixed
• fix: derived_ratio calculation
• fix: fill_t assignment operator fixed
• fix: improve downcast mode off
• fix: radioactivity header compilation fixed
• fix: si::hep::dim_momentum duplicated definition fixed
• fix: fps can now coexist with international system
• fix: public headers fixed to be standalone
• test: standalone public headers tests added
• (!) build: CMake generator in Conan is no longer obtained from an environment variable
• (!) build: Required Conan version bumped to 1.48
• (!) build: Conan 1.48 does not set CMAKE_BUILD_TYPE in the conan_toolchain.cmake anymore
• build: AppleClang 13 support added (thanks @fdischner)
• build: most of the conanfile.py refactored to be Conan 2.0 ready
• build: validate() replaced with configure() to raise errors during conan install in Conan 1.X
• build: minimum Conan version changed to 1.40
• build: linear-algebra Conan repo is no needed anymore
• build: Gitpod support added
• build: clang-format-15 support added
• build: export config to local build (#322)
• build: fix export name of mp-units-system
• build: fmt updated to 8.0.1
• build: gsl-lite updated to 0.40.0
• build: catch2 updated to 2.13.9
• build: doxygen updated to 1.9.4
• build: linear_algebra/0.7.0 switched to wg21-linear_algebra/0.7.2
• ci: VS2022, gcc-11, clang-13, clang-14, and AppleClang 13 support added
• ci: pre-commit support added (thanks @hofbi)
• docs: Project documentation updated
• docs: CITATION.cff file added
• docs: CONTRIBUTING.md updated

0.7.0 May 11, 2021

• (!) refactor: ScalableNumber renamed to Representation
• (!) refactor: output stream operators moved to the units/quantity_io.h header file
• (!) refactor: Refactored the library file tree
• (!) refactor: quantity::count() renamed to quantity::number()
• (!) refactor: data system renamed to isq::iec80000 (quantity names renamed too)
• (!) refactor: *deduced_unit renamed to *derived_unit
• (!) refactor: got rid of a noble_derived_unit
• refactor: quantity (kind) point updated to reflect latest changes to quantity
• refactor: basic concepts, quantity and quantity_cast refactored
• refactor: abs() definition refactored to be more explicit about the return type
• feat: quantity (point) kind support added (thanks @johelegp)
• feat: quantity references support added (thanks @johelegp)
• feat: quantity aliases support added
• feat: interoperability with std::chrono::duration and other units libraries
• feat: CTAD for dimensionless quantity added
• feat: modulation_rate support added (thanks @go2sh)
• feat: SI prefixes for isq::iec80000 support added (thanks @go2sh)
• feat: a possibility to disable quantity UDLs support with UNITS_NO_LITERALS preprocessor define
• feat: a support to define ISQ derived dimensions in terms of different number or order of components
• perf: preconditions check do not influence the runtime performance of a Release build
• perf: quantity_cast() generates less assembly instructions
• perf: temporary string creation removed from quantity::op<<()
• perf: value initialization for quantity value removed (left with a default initialization)
• perf: limited the equivalent trait usage
• perf: limited the C++ Standard Library headers usage
• perf: rvalue references support added for constructors and getters
• (!) fix: exp() has sense only for dimensionless quantities
• (!) fix: dim_torque now properly divides by an angle (instead of multiply) + default unit name change
• fix: quantity's operators fixed to behave like the underlying types do
• fix: quantity_cast() fixed to work correctly with representation types not convertible from std::intmax_t
• fix: ambiguous case for empty type list resolved
• fix: downcasting facility for non-default-constructible types
• fix: restore user-warnings within the library implementation
• fix: the text symbol of foot_pound_force and foot_pound_force_per_second
• fix: quantity modulo arithmetics fixed
• (!) build: Conan testing version is now hosted on Artifactory
• (!) build: Linear Algebra is now hosted on its Artifactory
• (!) build: BUILD_DOCS CMake option renamed to UNITS_BUILD_DOCS
• build: doxygen updated to 1.8.20
• build: catch2 updated to 2.13.4
• build: fmt updated to 7.1.3
• build: ms-gsl replaced with gsl-lite/0.38.0
• build: Conan generator switched to cmake_find_package_multi
• build: Conan CMakeToolchain support added
• build: CMake scripts cleanup
• build: ccache support added
• ci: CI switched from Travis CI to GitHub Actions

0.6.0 September 13, 2020

• feat: quantity_point support added (thanks @johelegp)
• feat: Added angle as SI base dimension (thanks @kwikius)
• feat: si::angular_velocity support added (thanks @mikeford3)
• feat: FPS system added (thanks @mikeford3)
• feat: Added support for mathematical function exp(quantity)
• feat: Localization support for text output added (thanks @rbrugo)
• feat: Added STL random number distribution wrappers (thanks @yasamoka)
• (!) refactor: Refactored and cleaned up the library file tree
• (!) refactor: q_* UDL renamed to _q_*
• (!) refactor: UDLs with "per" in name renamed from *p* to *_per_*
• (!) refactor: ratio changed to the NTTP kind
• (!) refactor: exp and Exp renamed to exponent and Exponent
• (!) refactor: Scalar concept renamed to ScalableNumber
• (!) refactor: Dimensionless quantities redesigned to be of a quantity type
• refactor: math.h function signatures refactored to use a Quantity concept (thanks @kwikius)
• refactor: [[nodiscard]] added to many functions
• fix: si::day unit symbol fixed to d (thanks @komputerwiz)
• fix: si::mole unit symbol fixed to mol (thanks @mikeford3)
• (!) build: gcc-9 is no longer supported (at least gcc-10 is required)
• build: Visual Studio 16.7 support added
• build: linear_algebra updated to 0.7.0/stable
• build: fmt updated to 7.0.3
• build: range-v3 updated to 0.11.0
• build: catch2 updated to 2.13.0
• build: doxygen updated to 1.8.18
• build: ms-gsl 3.1.0 dependency added
• build: Removed the dependency on a git submodule with common CMake scripts

0.5.0 May 17, 2020

• Major refactoring and rewrite of the library
• Units are now independent from dimensions
• Dimensions now depend on units (base or coherent units are provided in a class template)
• Quantity gets a Dimension template parameter again (as unit does not provide information about its dimension anymore)
• Spaceship operator support added
• Added official CGS system support
• Added official data information system support
• Repository file tree cleanup
• ratio refactored to contain Exp template parameter (thanks a lot @oschonrock!)
• SI fundamental constants added
• q_ prefix applied to all the UDLs (thanks @kwikius)
• unknown_unit renamed to unknown_coherent_unit
• Project documentation greatly extended and switched to Sphinx
• A few more usage examples added
• ASCII-only output support added (thanks @yasamoka)
• Representation values formatting extended (thanks @rbrugo)
• Output streams formatting support added
• Linear algebra from std::experimental::math support added
• Named SI units and their dimensions added (thanks @rbrugo
• libfmt updated to 6.2.0
• Added absolute functions and epsilon to math.h (thanks @mikeford3)
• Added a lot of prefixes to named units and introduced alias_unit (thanks @yasamoka)
• Linking with Conan targets only when they exists (#98)
• All physical dimensions and units put into physical namespace
• CMake improvements
• Velocity renamed to speed

Many thanks to GitHub users @oschonrock, @kwikius, and @i-ky for their support in drafting a new library design.

0.4.0 Nov 17, 2019

• Support for derived dimensions in exp added
• Added pow() and sqrt() operations on quantities
• units removed from a std::experimental namespace
• Downcasting facility refactored so the user does not have to write the boilerplate code anymore
• From now on base dimensions should inherit from base_dimension class template
• Added unit symbols definitions to base_dimension and derived units
• Added support for operator<< on quantity
• fmt support added
• Derived unit factory helpers refactored
• Refactored the way prefixed units are defined

0.3.1 Sep 18, 2019

• cmcstl2 dependency changed to range-v3 0.9.1

0.3.0 Sep 16, 2019

• The design as described on CppCon 2019 talk (https://youtu.be/0YW6yxkdhlU)
• Applied the feedback from the Cologne evening session
  • upcasting_traits renamed to downcasting_traits
  • Dimension template parameter removed from quantity
• units moved to a std::experimental namespace
• Leading underscore prefix removed from UDLs
• Added a few more derived dimensions
• meter renamed to metre
• Missing operator* added
• Predefined dimensions moved to a dedicated directory
• dimension_ prefix removed from names of derived dimensions
• cmcstl2 library updated to 2019.09.19
• base_dimension is a value provided as const& to the exp type
• integrated with Compiler Explorer
• gsl-lite dependency removed
• Fractional dimension exponents support added
• QuantityOf concept introduced
• quantity_cast<U, Rep>() support added

0.2.0 July 18, 2019

• The design as described on C++Now 2019 talk (https://youtu.be/wKchCktZPHU)
• Added C++20 features supported by gcc-9.1 (std::remove_cvref_t, down with typename, std::type_identity)
• Compile-time performance optimizations (type_list, common_ratio, ratio, conditional_t)

0.1.0 May 18, 2019

• Initial library release
• Begin semantic versioning
• The last version to work with gcc-8