mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2026-07-08 09:30:52 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
d8b72fc4315f7440bc59305db408ffe38f189f21
mp-units/test/static/usc_test.cpp
T
Mateusz Pusz efbc844199 fix: fixed-point arithmetic for integer unit conversions (#580) (#764) 
* Fix #580: use fixed-point arithmetic for integer unit conversions

Introduce a fixed-point implementation for unit conversions involving
integer representations, avoiding loss of significant digits that
previously occurred when the conversion factor was not a whole number.

New files:
- src/core/include/mp-units/bits/fixed_point.h: double_width_int<T> and
  fixed_point<T,n> types for exact rational scaling of integer values.
  Uses __int128 when available (__SIZEOF_INT128__) for 64-bit integers.
- src/core/include/mp-units/framework/scaling.h: public scaling_traits<>
  customization point and scale<To>(M, value) free function. Provides
  built-in specializations for floating-point and integer-like types.
- test/static/fixed_point_test.cpp: static assertions for the new types.
- test/runtime/fixed_point_test.cpp: runtime arithmetic edge-case tests.

Modified:
- sudo_cast.h: replace hand-rolled conversion_value_traits / sudo_cast_value
  machinery with a single scale<To::rep>(c_mag, ...) call.
- representation_concepts.h: add MagnitudeScalable concept; replace
  ComplexScalar with HasComplexOperations (which is its definition).
- customization_points.h: add unspecified_rep tag and declare the primary
  scaling_traits<> template.
- framework.h / CMakeLists.txt: wire in the new headers.
- hacks.h: add MP_UNITS_DIAGNOSTIC_IGNORE_PEDANTIC and
  MP_UNITS_DIAGNOSTIC_IGNORE_SIGN_CONVERSION macros.
- example/measurement.cpp: add scaling_traits specializations for
  measurement<T> to demonstrate the customization point.
- test/static/{international,usc}_test.cpp: disable two tests that are
  blocked on issue #614.

Co-authored-by: Tobias Hanhart <burnpanck@users.noreply.github.com>

* Fix value_Type typo in floating_point_scaling_factor_type specialization

The partial specialization for types with a nested value_type used
'value_Type' (capital T) instead of 'value_type', making the entire
specialization dead code as the requires-clause could never be satisfied.

Also fix 'mantiassa' -> 'mantissa' in the adjacent comment.

* Fix docstring typos in scaling_traits documentation

- 'quantitiy' -> 'quantity'
- 'dictatet' -> 'dictated'
- 'convetrible' -> 'convertible'
- 'implemenation' -> 'implementation'
- 'availabe' -> 'available'

* Fix conflict resolution error: keep ComplexScalar name from master

When resolving the merge conflict in representation_concepts.h, the
PR's renamed version of the concept ('HasComplexOperations') was used
instead of master's established name ('ComplexScalar'). The two concepts
are semantically equivalent — burnpanck simply renamed it in his branch.

Revert to the canonical 'ComplexScalar' name while retaining the new
'MagnitudeScalable' concept which was the actual addition from the PR.

* Fix measurement.cpp: remove duplicate class definition from merge

The PR branched from a version where measurement<T> was defined inline
in measurement.cpp. Master later moved the class to example/include/
measurement.h and changed measurement.cpp to #include that header.

The squash merge therefore introduced a duplicate definition: the class
from the header and the PR's inline class were both visible, causing
an 'ambiguous reference' error. Remove the now-redundant inline class;
the scaling_traits specializations added by the PR work correctly with
the class from measurement.h.

* style: pre-commit

* docs: chapters anchors improved in the "custom representation" chapter

* docs: value conversions chapter improved

* refactor: scaling support refactored

* fix: clang-16 crash fixed

* docs: `measurement` example documentation updated to match changes

* fix: use exact wide-integer arithmetic for rational unit conversions on all platforms

On ARM / Apple Silicon, long double == double (64-bit mantissa).  The old
fixed_point<T>(long double) initialiser lost ~12 bits of precision for 64-bit
integer types when representing the scaling ratio, producing an error of ~49
units for the 10/9 (degree → gradian) conversion with a 10^18 input value.

Fix by splitting the integer-path else-branch into two cases:

  • Pure rational M (is_integral(M * (denominator(M) / numerator(M))) == true):
    use (value * numerator) / denominator via double_width_int_for_t<> arithmetic.
    This is exact on every platform regardless of long double width.

  • Irrational M (involves π etc.): keep the long double fixed_point approximation.
    These conversions are inherently approximate; small values still produce correct
    truncated results on all platforms.

Update the test comment to reflect the new exact-arithmetic path.

Fixes CI failures on clang-18/ARM and apple-clang-16.

* fix: replace floating-point TeX-point test with exact integer equivalent

72.27 is not exactly representable as double (it rounds to 72.2699...96).
Multiplying by the conversion factor 100/7227 via long double gives a result
≥ 1.0 on x86 (80-bit long double, 64-bit mantissa) only by chance, but
0.99999...978 on ARM / Apple Silicon where long double == double (52-bit).

The correct mathematical statement is: 7227 tex_point = 100 inch (exact
rational relationship).  Use that integer form instead of the inexact 72.27
double literal so the test is correct and platform-independent.

---------

Co-authored-by: Tobias Hanhart <burnpanck@users.noreply.github.com>
2026-03-07 21:02:37 +01:00

132 lines
6.3 KiB
C++
Raw Blame History

// The MIT License (MIT)
//
// Copyright (c) 2018 Mateusz Pusz
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include <mp-units/bits/hacks.h>
#include <mp-units/systems/isq/mechanics.h>
#include <mp-units/systems/isq/space_and_time.h>
#include <mp-units/systems/si/prefixes.h>
#include <mp-units/systems/si/units.h>
#include <mp-units/systems/usc.h>
namespace {
using namespace mp_units;
using namespace mp_units::usc;
using namespace mp_units::usc::unit_symbols;
/* ************** BASE DIMENSIONS **************** */
// https://en.wikipedia.org/wiki/United_States_customary_units#Length
// International
static_assert(isq::length(20 * twip) == isq::length(1 * p));
static_assert(isq::length(1000 * mil) == isq::length(1 * in));
static_assert(isq::length(72 * p) == isq::length(1 * in));
static_assert(isq::length(1 * P) == isq::length(12 * p));
static_assert(isq::length(1 * in) == isq::length(6 * P));
static_assert(isq::length(1 * ft) == isq::length(12 * in));
static_assert(isq::length(1 * yd) == isq::length(3 * ft));
static_assert(isq::length(1 * mi) == isq::length(5280 * ft));
// International Nautical
static_assert(isq::length(1 * cb) == isq::length(120 * ftm));
static_assert(isq::length(1 * nmi) == isq::length(1852 * si::metre));
// US survey
MP_UNITS_DIAGNOSTIC_PUSH
MP_UNITS_DIAGNOSTIC_IGNORE_DEPRECATED
static_assert(isq::length(3937 * us_ft) == isq::length(1200 * si::metre));
static_assert(isq::length(3937 * us_mi) == isq::length(6336 * si::kilo<si::metre>));
MP_UNITS_DIAGNOSTIC_POP
static_assert(isq::length(50 * li) == isq::length(33 * ft));
static_assert(isq::length(1 * rd) == isq::length(25 * li));
static_assert(isq::length(1 * ch) == isq::length(4 * rd));
static_assert(isq::length(1 * fur) == isq::length(10 * ch));
static_assert(isq::length(1 * lea) == isq::length(3 * mi));
static_assert(isq::length(50 * survey1893::link) == isq::length(33 * survey1893::us_survey_foot));
static_assert(isq::length(3937 * survey1893::us_survey_foot) == isq::length(1200 * si::metre));
static_assert(isq::length(1 * survey1893::rod) == isq::length(25 * survey1893::link));
static_assert(isq::length(1 * survey1893::chain) == isq::length(4 * survey1893::rod));
static_assert(isq::length(1 * survey1893::furlong) == isq::length(10 * survey1893::chain));
static_assert(isq::length(1 * survey1893::us_survey_mile) == isq::length(8 * survey1893::furlong));
static_assert(isq::length(1 * survey1893::league) == isq::length(3 * survey1893::us_survey_mile));
// Area
// TODO verify the below
// static_assert(isq::area(1 * square(survey1893::us_survey_foot)) == isq::area(144 * square(inch)));
static_assert(isq::area(1 * square(survey1893::chain)) == isq::area(4356 * square(survey1893::us_survey_foot)));
static_assert(isq::area(1 * acre) == isq::area(43560 * square(survey1893::us_survey_foot)));
static_assert(isq::area(1 * section) == isq::area(1 * square(survey1893::us_survey_mile)));
// Volume
static_assert(isq::volume(1 * cubic(foot)) == isq::volume(1'728 * cubic(inch)));
static_assert(isq::volume(1 * cubic(yard)) == isq::volume(27 * cubic(foot)));
static_assert(isq::volume(1 * (acre * survey1893::us_survey_foot)) ==
isq::volume(43'560 * cubic(survey1893::us_survey_foot)));
// Fluid volume
static_assert(isq::volume(1 * fl_dr) == isq::volume(60 * min));
static_assert(isq::volume(1 * tsp) == isq::volume(80 * min));
static_assert(isq::volume(1 * tbsp) == isq::volume(3 * tsp));
static_assert(isq::volume(1 * fl_oz) == isq::volume(2 * tbsp));
static_assert(isq::volume(1 * jig) == isq::volume(3 * tbsp));
static_assert(isq::volume(1 * gi) == isq::volume(4 * fl_oz));
static_assert(isq::volume(1 * c) == isq::volume(2 * gi));
static_assert(isq::volume(1 * pt) == isq::volume(2 * c));
static_assert(isq::volume(1 * qt) == isq::volume(2 * pt));
static_assert(isq::volume(1 * pot) == isq::volume(2 * qt));
static_assert(isq::volume(1 * gal) == isq::volume(4 * qt));
static_assert(isq::volume(2 * bbl) == isq::volume(63 * gal));
static_assert(isq::volume(3 * oil_barrel) == isq::volume(4 * bbl));
static_assert(isq::volume(2 * hogshead) == isq::volume(3 * oil_barrel));
// Dry volume
static_assert(isq::volume(1 * dry_qt) == isq::volume(2 * dry_pt));
static_assert(isq::volume(1 * dry_gal) == isq::volume(4 * dry_qt));
static_assert(isq::volume(1 * pk) == isq::volume(2 * dry_gal));
static_assert(isq::volume(1 * bu) == isq::volume(4 * pk));
static_assert(isq::volume(1 * dry_bbl) == isq::volume(7056 * cubic(inch)));
// Mass
static_assert(isq::mass(7'000 * gr) == isq::mass(1 * lb));
static_assert(isq::mass(32 * dr) == isq::mass(875 * gr));
static_assert(isq::mass(1 * oz) == isq::mass(16 * dr));
static_assert(isq::mass(1 * lb) == isq::mass(16 * oz));
static_assert(isq::mass(1 * qr) == isq::mass(25 * lb));
static_assert(isq::mass(1 * cwt) == isq::mass(4 * qr));
static_assert(isq::mass(1 * t) == isq::mass(20 * cwt));
static_assert(isq::mass(1 * dwt) == isq::mass(24 * gr));
static_assert(isq::mass(1 * oz_t) == isq::mass(20 * dwt));
static_assert(isq::mass(1 * lb_t) == isq::mass(12 * oz_t));
// Pressure
// the next test is currently disabled; it surfaced #614
// static_assert(isq::pressure(1'000 * inHg) == isq::pressure(3'386'389 * si::pascal));
// Temperature
static_assert(delta<isq::thermodynamic_temperature[deg_F]>(9) ==
delta<isq::thermodynamic_temperature[si::degree_Celsius]>(5));
} // namespace
Reference in New Issue View Git Blame Copy Permalink