mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2026-07-05 08:01:01 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
7f1e417c06f6a7f3fdfa052dff0721fd51cc2f94
mp-units/test/static/custom_rep_test_min_impl.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

241 lines
14 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/framework.h>
#include <mp-units/systems/si/prefixes.h>
#include <mp-units/systems/si/units.h>
#ifdef MP_UNITS_IMPORT_STD
import std;
#else
#include <concepts>
#include <type_traits>
#endif
namespace {
/**
* @brief Implicitly constructible and convertible representation type
*
* A wrapper type that is implicitly convertible from and to the contained type.
*
* @tparam T element type
*/
template<typename T>
class min_impl {
T value_;
public:
using value_type = T;
min_impl() = default;
// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(false) min_impl(T v) noexcept : value_(v) {}
template<typename U>
// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(false) min_impl(min_impl<U> i) noexcept : value_(static_cast<T>(static_cast<U>(i)))
{
}
// NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
constexpr explicit(false) operator T() const noexcept { return value_; }
};
} // namespace
template<typename T, typename U>
struct std::common_type<min_impl<T>, min_impl<U>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
template<typename T, typename U>
struct std::common_type<min_impl<T>, U> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
template<typename U, typename T>
struct std::common_type<U, min_impl<T>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
namespace {
using namespace mp_units;
static_assert(RepresentationOf<min_impl<int>, quantity_character::real_scalar>);
static_assert(RepresentationOf<min_impl<double>, quantity_character::real_scalar>);
// construction from a value is not allowed
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, min_impl<int>>);
static_assert(!std::convertible_to<min_impl<int>, quantity<si::metre, min_impl<int>>>);
static_assert(!std::constructible_from<quantity<si::metre, min_impl<double>>, min_impl<double>>);
static_assert(!std::convertible_to<min_impl<double>, quantity<si::metre, min_impl<double>>>);
// multiply syntax should work
template<typename T, auto U>
concept creates_quantity = Unit<MP_UNITS_REMOVE_CONST(decltype(U))> && requires { T{} * U; };
static_assert(creates_quantity<min_impl<int>, si::metre>);
static_assert(creates_quantity<min_impl<double>, si::metre>);
// multiply syntax
static_assert(creates_quantity<min_impl<int>, one>);
static_assert(creates_quantity<min_impl<double>, one>);
static_assert(creates_quantity<min_impl<int>, percent>);
static_assert(creates_quantity<min_impl<double>, percent>);
// construction from a quantity
// min_impl<T> -> min_impl<T>
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<double>>>);
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>,
quantity<si::metre, min_impl<double>>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
// T -> min_impl<T>
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
static_assert(std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>);
static_assert(
!std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
// min_impl<T> -> T
static_assert(std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>);
static_assert(
!std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
// arithmetic operators
static_assert(min_impl<int>{1} * si::metre + min_impl<int>{1} * si::metre == min_impl<int>{2} * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<double>{1.5} * si::metre == min_impl<double>{2.5} * si::metre);
static_assert(1 * si::metre + min_impl<int>{1} * si::metre == min_impl<int>{2} * si::metre);
static_assert(1 * si::metre + min_impl<double>{1.5} * si::metre == min_impl<double>{2.5} * si::metre);
static_assert(min_impl<int>{1} * si::metre + 1 * si::metre == min_impl<int>{2} * si::metre);
static_assert(min_impl<int>{1} * si::metre + 1.5 * si::metre == min_impl<double>{2.5} * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<int>{1} * si::metre == 2 * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<double>{1.5} * si::metre == 2.5 * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + min_impl<int>{1} * si::metre ==
min_impl<int>{1'001} * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + min_impl<double>{1.5} * si::metre ==
min_impl<double>{1001.5} * si::metre);
static_assert(1 * si::kilo<si::metre> + min_impl<int>{1} * si::metre == min_impl<int>{1'001} * si::metre);
static_assert(1 * si::kilo<si::metre> + min_impl<double>{1.5} * si::metre == min_impl<double>{1001.5} * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + 1 * si::metre == min_impl<int>{1'001} * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + 1.5 * si::metre == min_impl<double>{1001.5} * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + min_impl<int>{1} * si::metre == 1'001 * si::metre);
static_assert(min_impl<int>{1} * si::kilo<si::metre> + min_impl<double>{1.5} * si::metre == 1001.5 * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<int>{1} * si::kilo<si::metre> ==
min_impl<int>{1'001} * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<double>{1.5} * si::kilo<si::metre> ==
min_impl<double>{1'501} * si::metre);
static_assert(1 * si::metre + min_impl<int>{1} * si::kilo<si::metre> == min_impl<int>{1'001} * si::metre);
static_assert(1 * si::metre + min_impl<double>{1.5} * si::kilo<si::metre> == min_impl<double>{1'501} * si::metre);
static_assert(min_impl<int>{1} * si::metre + 1 * si::kilo<si::metre> == min_impl<int>{1'001} * si::metre);
static_assert(min_impl<int>{1} * si::metre + 1.5 * si::kilo<si::metre> == min_impl<double>{1'501} * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<int>{1} * si::kilo<si::metre> == 1'001 * si::metre);
static_assert(min_impl<int>{1} * si::metre + min_impl<double>{1.5} * si::kilo<si::metre> == double{1'501} * si::metre);
static_assert(min_impl<int>{2} * si::metre - min_impl<int>{1} * si::metre == min_impl<int>{1} * si::metre);
static_assert(min_impl<int>{2} * si::metre - min_impl<double>{1.5} * si::metre == min_impl<double>{0.5} * si::metre);
static_assert(2 * si::metre - min_impl<int>{1} * si::metre == min_impl<int>{1} * si::metre);
static_assert(2 * si::metre - min_impl<double>{1.5} * si::metre == min_impl<double>{0.5} * si::metre);
static_assert(min_impl<int>{2} * si::metre - 1 * si::metre == min_impl<int>{1} * si::metre);
static_assert(min_impl<int>{2} * si::metre - 1.5 * si::metre == min_impl<double>{0.5} * si::metre);
static_assert(min_impl<int>{2} * si::metre - min_impl<int>{1} * si::metre == 1 * si::metre);
static_assert(min_impl<int>{2} * si::metre - min_impl<double>{1.5} * si::metre == 0.5 * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - min_impl<int>{1} * si::metre ==
min_impl<int>{1'999} * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - min_impl<double>{1.5} * si::metre ==
min_impl<double>{1998.5} * si::metre);
static_assert(2 * si::kilo<si::metre> - min_impl<int>{1} * si::metre == min_impl<int>{1'999} * si::metre);
static_assert(2 * si::kilo<si::metre> - min_impl<double>{1.5} * si::metre == min_impl<double>{1998.5} * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - 1 * si::metre == min_impl<int>{1'999} * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - 1.5 * si::metre == min_impl<double>{1998.5} * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - min_impl<int>{1} * si::metre == 1'999 * si::metre);
static_assert(min_impl<int>{2} * si::kilo<si::metre> - min_impl<double>{1.5} * si::metre == 1998.5 * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - min_impl<int>{1} * si::kilo<si::metre> ==
min_impl<int>{1'000} * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - min_impl<double>{1.5} * si::kilo<si::metre> ==
min_impl<double>{500} * si::metre);
static_assert(2'000 * si::metre - min_impl<int>{1} * si::kilo<si::metre> == min_impl<int>{1'000} * si::metre);
static_assert(2'000 * si::metre - min_impl<double>{1.5} * si::kilo<si::metre> == min_impl<double>{500} * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - 1 * si::kilo<si::metre> == min_impl<int>{1'000} * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - 1.5 * si::kilo<si::metre> == min_impl<double>{500} * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - min_impl<int>{1} * si::kilo<si::metre> == 1'000 * si::metre);
static_assert(min_impl<int>{2'000} * si::metre - min_impl<double>{1.5} * si::kilo<si::metre> ==
double{500} * si::metre);
static_assert(min_impl<int>{123} * si::metre * min_impl<double>(1.5) == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre * 1.5 == min_impl<double>{184.5} * si::metre);
static_assert(123 * si::metre * min_impl<double>(1.5) == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre * (min_impl<double>(1.5) * one) == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre * (1.5 * one) == min_impl<double>{184.5} * si::metre);
static_assert(123 * si::metre * (min_impl<double>(1.5) * one) == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<double>(1.5) * min_impl<int>{123} * si::metre == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<double>(1.5) * 123 * si::metre == min_impl<double>{184.5} * si::metre);
static_assert(1.5 * min_impl<int>{123} * si::metre == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<double>(1.5) * one * (min_impl<int>{123} * si::metre) == min_impl<double>{184.5} * si::metre);
static_assert(min_impl<double>(1.5) * one * (123 * si::metre) == min_impl<double>{184.5} * si::metre);
static_assert(1.5 * one * (min_impl<int>{123} * si::metre) == min_impl<double>{184.5} * si::metre);
#ifndef MP_UNITS_COMP_CLANG
static_assert(min_impl<int>{123} * si::metre / min_impl<double>(2.) == min_impl<double>{61.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre / 2. == min_impl<double>{61.5} * si::metre);
static_assert(123 * si::metre / min_impl<double>(2.) == min_impl<double>{61.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre / (min_impl<double>(2.) * one) == min_impl<double>{61.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre / (2. * one) == min_impl<double>{61.5} * si::metre);
static_assert(123 * si::metre / (min_impl<double>(2.) * one) == min_impl<double>{61.5} * si::metre);
static_assert(min_impl<int>{123} * si::metre / (min_impl<double>{2.} * si::metre) == 61.5 * one);
static_assert(min_impl<int>{123} * si::metre / (2. * si::metre) == 61.5 * one);
static_assert(123 * si::metre / (min_impl<double>{2.} * si::metre) == 61.5 * one);
#endif
static_assert(min_impl<int>{123} * si::metre % (min_impl<int>(100) * si::metre) == 23 * si::metre);
static_assert(min_impl<int>{123} * si::metre % (100 * si::metre) == 23 * si::metre);
static_assert(123 * si::metre % (min_impl<int>(100) * si::metre) == 23 * si::metre);
} // namespace
Reference in New Issue View Git Blame Copy Permalink