/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef ProportionValue_h
#define ProportionValue_h
#include "mozilla/Attributes.h"
#include <algorithm>
#include <limits>
namespace mozilla {
// Class storing a proportion value between 0 and 1, effectively 0% to 100%.
// The public interface deals with doubles, but internally the value is encoded
// in an integral type, so arithmetic operations are fast.
// It also supports an invalid value: Use MakeInvalid() to construct, it infects
// any operation, and gets converted to a signaling NaN.
class ProportionValue {
public:
using UnderlyingType = uint32_t;
// Default-construct at 0%.
constexpr ProportionValue()
// This `noexcept` is necessary to avoid a build error when encapsulating
// `ProportionValue` in `std::Atomic`:
// "use of deleted function
// 'constexpr std::atomic<mozilla::ProportionValue>::atomic()"
// because the default `std::atomic<T>::atomic()` constructor is marked:
// `noexcept(std::is_nothrow_default_constructible_v<T>)`
// and therefore this default constructor here must be explicitly marked
// `noexcept` as well.
noexcept
: mIntegralValue(0u) {}
// Construct a ProportionValue with the given value, clamped to 0..1.
// Note that it's constexpr, so construction from literal numbers should incur
// no runtime costs.
// If `aValue` is NaN, behavior is undefined! Use `MakeInvalid()` instead.
constexpr
explicit ProportionValue(
double aValue)
: mIntegralValue(UnderlyingType(std::clamp(aValue, 0.0, 1.0) * scMaxD)) {}
[[nodiscard]]
static constexpr ProportionValue MakeInvalid() {
return ProportionValue(scInvalidU, Internal{});
}
[[nodiscard]] constexpr
double ToDouble()
const {
return IsInvalid() ? std::numeric_limits<
double>::signaling_NaN()
: (
double(mIntegralValue) * scInvMaxD);
}
// Retrieve the underlying integral value, for storage or testing purposes.
[[nodiscard]] constexpr UnderlyingType ToUnderlyingType()
const {
return mIntegralValue;
};
// Re-construct a ProportionValue from an underlying integral value.
[[nodiscard]]
static constexpr ProportionValue FromUnderlyingType(
UnderlyingType aUnderlyingType) {
return ProportionValue(
(aUnderlyingType <= scMaxU) ? aUnderlyingType : scInvalidU, Internal{});
}
[[nodiscard]] constexpr
bool IsExactlyZero()
const {
return mIntegralValue == 0u;
}
[[nodiscard]] constexpr
bool IsExactlyOne()
const {
return mIntegralValue == scMaxU;
}
[[nodiscard]] constexpr
bool IsValid()
const {
// Compare to the maximum value, not just exactly scInvalidU, to catch any
// kind of invalid state.
return mIntegralValue <= scMaxU;
}
[[nodiscard]] constexpr
bool IsInvalid()
const {
// Compare to the maximum value, not just exactly scInvalidU, to catch any
// kind of invalid state.
return mIntegralValue > scMaxU;
}
// Strict comparisons based on the underlying integral value. Use
// `CompareWithin` instead to make fuzzy comparisons.
// `ProportionValue::MakeInvalid()`s are equal, and greater than anything
// else; Best to avoid comparisons, and first use IsInvalid() instead.
#define OPERATOR_COMPARISON(CMP) \
[[nodiscard]] constexpr
friend bool operator CMP( \
const ProportionValue& aLHS,
const ProportionValue& aRHS) { \
return aLHS.mIntegralValue CMP aRHS.mIntegralValue; \
}
OPERATOR_COMPARISON(==)
OPERATOR_COMPARISON(!=)
OPERATOR_COMPARISON(<)
OPERATOR_COMPARISON(<=)
OPERATOR_COMPARISON(>)
OPERATOR_COMPARISON(>=)
#undef OPERATOR_COMPARISON
// Arithmetic operations + - *, all working on the underlying integral values
// (i.e, no expensive floating-point operations are used), and always clamping
// to 0..1 range. Invalid values are poisonous.
[[nodiscard]] constexpr ProportionValue
operator+(
ProportionValue aRHS)
const {
return ProportionValue(
(IsInvalid() || aRHS.IsInvalid())
? scInvalidU
// Adding fixed-point values keep the same scale, so there is no
// adjustment needed for that. [0,1]+[0,1]=[0,2], so we only need to
// ensure that the result is capped at max 1, aka scMaxU:
// a+b<=max <=> b<=max-a, so b is at maximum max-a.
: (mIntegralValue +
std::min(aRHS.mIntegralValue, scMaxU - mIntegralValue)),
Internal{});
}
[[nodiscard]] constexpr ProportionValue operator-(
ProportionValue aRHS)
const {
return ProportionValue(
(IsInvalid() || aRHS.IsInvalid())
? scInvalidU
// Subtracting fixed-point values keep the same scale, so there is
// no adjustment needed for that. [0,1]-[0,1]=[-1,1], so we only
// need to ensure that the value is positive:
// a-b>=0 <=> b<=a, so b is at maximum a.
: (mIntegralValue - std::min(aRHS.mIntegralValue, mIntegralValue)),
Internal{});
}
[[nodiscard]] constexpr ProportionValue
operator*(
ProportionValue aRHS)
const {
// Type to hold the full result of multiplying two maximum numbers.
using DoublePrecisionType = uint64_t;
static_assert(
sizeof(DoublePrecisionType) >= 2 *
sizeof(UnderlyingType));
return ProportionValue(
(IsInvalid() || aRHS.IsInvalid())
? scInvalidU
// Multiplying fixed-point values doubles the scale (2^31 -> 2^62),
// so we need to adjust the result by dividing it by one scale
// (which is optimized into a binary right-shift).
: (UnderlyingType((DoublePrecisionType(mIntegralValue) *
DoublePrecisionType(aRHS.mIntegralValue)) /
DoublePrecisionType(scMaxU))),
Internal{});
}
// Explicitly forbid divisions, they make little sense, and would almost
// always return a clamped 100% (E.g.: 50% / 10% = 0.5 / 0.1 = 5 = 500%).
[[nodiscard]] constexpr ProportionValue
operator/(
ProportionValue aRHS)
const =
delete;
// Division by a positive integer value, useful to split an interval in equal
// parts (with maybe some spare space at the end, because it is rounded down).
// Division by 0 produces an invalid value.
[[nodiscard]] constexpr ProportionValue
operator/(uint32_t aDivisor)
const {
return ProportionValue((IsInvalid() || aDivisor == 0u)
? scInvalidU
: (mIntegralValue / aDivisor),
Internal{});
}
// Multiplication by a positive integer value, useful as inverse of the
// integer division above. But it may be lossy because the division is rounded
// down, therefore: PV - u < (PV / u) * u <= PV.
// Clamped to 100% max.
[[nodiscard]] constexpr ProportionValue
operator*(
uint32_t aMultiplier)
const {
return ProportionValue(IsInvalid()
? scInvalidU
: ((aMultiplier > scMaxU / mIntegralValue)
? scMaxU
: (mIntegralValue * aMultiplier)),
Internal{});
}
private:
// Tagged constructor for internal construction from the UnderlyingType, so
// that it is never ambiguously considered in constructions from one number.
struct Internal {};
constexpr ProportionValue(UnderlyingType aIntegralValue, Internal)
: mIntegralValue(aIntegralValue) {}
// Use all but 1 bit for the fractional part.
// Valid values can go from 0b0 (0%) up to 0b1000...00 (scMaxU aka 100%).
static constexpr
unsigned scFractionalBits =
sizeof(UnderlyingType) * 8 - 1;
// Maximum value corresponding to 1.0 or 100%.
static constexpr UnderlyingType scMaxU = UnderlyingType(1u)
<< scFractionalBits;
// This maximum value corresponding to 1.0 can also be seen as the scaling
// factor from any [0,1] `double` value to the internal integral value.
static constexpr
double scMaxD =
double(scMaxU);
// The inverse can be used to convert the internal value back to [0,1].
static constexpr
double scInvMaxD = 1.0 / scMaxD;
// Special value outside [0,max], used to construct invalid values.
static constexpr UnderlyingType scInvalidU = ~UnderlyingType(0u);
// Internal integral value, guaranteed to always be <= scMaxU, or scInvalidU.
// This is effectively a fixed-point value using 1 bit for the integer part
// and 31 bits for the fractional part.
// It is roughly equal to the `double` value [0,1] multiplied by scMaxD.
UnderlyingType mIntegralValue;
};
namespace literals {
inline namespace ProportionValue_literals {
// User-defined literal for integer percentages, e.g.: `10_pc`, `100_pc`
// (equivalent to `ProportionValue{0.1}` and `ProportionValue{1.0}`).
// Clamped to [0, 100]_pc.
[[nodiscard]] constexpr ProportionValue
operator""_pc(
unsigned long long int aPercentage) {
return ProportionValue{
double(std::clamp<
unsigned long long int>(aPercentage, 0u, 100u)) /
100.0};
}
// User-defined literal for non-integer percentages, e.g.: `12.3_pc`, `100.0_pc`
// (equivalent to `ProportionValue{0.123}` and `ProportionValue{1.0}`).
// Clamped to [0.0, 100.0]_pc.
[[nodiscard]] constexpr ProportionValue
operator""_pc(
long double aPercentage) {
return ProportionValue{
double(std::clamp<
long double>(aPercentage, 0.0, 100.0)) / 100.0};
}
}
// namespace ProportionValue_literals
}
// namespace literals
}
// namespace mozilla
#endif // ProportionValue_h
