std::decimal(3cxx)

📦

version 14-20240412 · 11 versions

💖 std::decimal 💖

ok so real talk, this is std::decimal from the 3cxx manual — the whole ISO/IEC TR 24733 Decimal floating-point arithmetic situation. yes, it's a mouthful. no, you don't have to memorise it. it's giving "spec document energy" and honestly? we respect it. 🎀

✨ SYNOPSIS ✨

🦋 Classes

like, this is the whole cast of characters, bestie — three of them, all decimal, all floating-point, all iconic in their own way:

class decimal128 — that's 3.2.4 Class decimal128, the one with the big-girl digits 💅
class decimal32 — 3.2.2 Class decimal32, the smol one, cute, compact ✨
class decimal64 — 3.2.3 Class decimal64, the middle child, and honestly? she's serving 🫶

and yes, the numbers are literally 3.2.4, 3.2.2, 3.2.3 in that order up there — not me re-sorting them, that's just how the page said it. we keep it exactly as it comes, fr fr 💀

🛠️ Functions

okay bestie, this is the part where the page goes absolutely feral with overloads — but honestly? iconic behaviour. Every one of these lives in the std::decimal namespace and slays in its own little way. Buckle up, we're going through them in order. 💅

double decimal128_to_double (decimal128 __d) — takes your decimal128 and hands you back a plain double.
float decimal128_to_float (decimal128 __d) — same deal, but the result is a float.
long double decimal128_to_long_double (decimal128 __d) — yup, decimal128 → long double.
long long decimal128_to_long_long (decimal128 __d) — decimal128 in, long long out.
double decimal32_to_double (decimal32 __d) — decimal32 → double, no notes.
float decimal32_to_float (decimal32 __d) — decimal32 → float.
long double decimal32_to_long_double (decimal32 __d) — decimal32 → long double.
long long decimal32_to_long_long (decimal32 __d) — decimal32 → long long. 🫶

"Non-conforming extension: Conversion to integral type." — that's a direct quote from the page, so like… it exists, it works, but it's not conforming. Don't act surprised when someone side-eyes you for using it. 🙈

double decimal64_to_double (decimal64 __d) — decimal64 → double.
float decimal64_to_float (decimal64 __d) — decimal64 → float.
long double decimal64_to_long_double (decimal64 __d) — decimal64 → long double.
long long decimal64_to_long_long (decimal64 __d) — decimal64 → long long.

then we get the ✨generic-flavoured✨ names, which are just the same three source types over and over and I'm obsessed with the consistency:

double decimal_to_double (decimal128 __d) — decimal128 → double.
double decimal_to_double (decimal32 __d) — decimal32 → double.
double decimal_to_double (decimal64 __d) — decimal64 → double.
float decimal_to_float (decimal128 __d) — decimal128 → float.
float decimal_to_float (decimal32 __d) — decimal32 → float.
float decimal_to_float (decimal64 __d) — decimal64 → float.
long double decimal_to_long_double (decimal128 __d) — decimal128 → long double.
long double decimal_to_long_double (decimal32 __d) — decimal32 → long double.
long double decimal_to_long_double (decimal64 __d) — decimal64 → long double.
long long decimal_to_long_long (decimal128 __d) — decimal128 → long long.
long long decimal_to_long_long (decimal32 __d) — decimal32 → long long.
long long decimal_to_long_long (decimal64 __d) — decimal64 → long long.

🌸 the `make_*` girlies (they're `static`, very exclusive)

static decimal128 make_decimal128 (long long __coeff, int __exp) — builds a decimal128 out of a long long coefficient plus an int exponent.
static decimal128 make_decimal128 (unsigned long long __coeff, int __exp) — same, but the coefficient is unsigned long long.
static decimal32 make_decimal32 (long long __coeff, int __exp) — decimal32 from a long long coefficient and an int exponent.
static decimal32 make_decimal32 (unsigned long long __coeff, int __exp) — unsigned coefficient edition.
static decimal64 make_decimal64 (long long __coeff, int __exp) — decimal64 from long long coefficient + int exponent.
static decimal64 make_decimal64 (unsigned long long __coeff, int __exp) — and the unsigned long long twin. 🎀

💀 `operator!=` — the not-equal squad (there are SO many)

every single one of these returns bool, and every single one is a vibe check on "are these two not the same". starting with decimal128 on the left:

bool operator!= (decimal128 __lhs, decimal128 __rhs) — decimal128 vs decimal128.
bool operator!= (decimal128 __lhs, decimal32 __rhs) — decimal128 vs decimal32.
bool operator!= (decimal128 __lhs, decimal64 __rhs) — decimal128 vs decimal64.
bool operator!= (decimal128 __lhs, int __rhs) — decimal128 vs int.
bool operator!= (decimal128 __lhs, long __rhs) — decimal128 vs long.
bool operator!= (decimal128 __lhs, long long __rhs) — decimal128 vs long long.
bool operator!= (decimal128 __lhs, unsigned int __rhs) — decimal128 vs unsigned int.
bool operator!= (decimal128 __lhs, unsigned long __rhs) — decimal128 vs unsigned long.
bool operator!= (decimal128 __lhs, unsigned long long __rhs) — decimal128 vs unsigned long long.

same energy, decimal32 on the left this time:

bool operator!= (decimal32 __lhs, decimal128 __rhs) — decimal32 vs decimal128.
bool operator!= (decimal32 __lhs, decimal32 __rhs) — decimal32 vs decimal32.
bool operator!= (decimal32 __lhs, decimal64 __rhs) — decimal32 vs decimal64.
bool operator!= (decimal32 __lhs, int __rhs) — decimal32 vs int.
bool operator!= (decimal32 __lhs, long __rhs) — decimal32 vs long.
bool operator!= (decimal32 __lhs, long long __rhs) — decimal32 vs long long.
bool operator!= (decimal32 __lhs, unsigned int __rhs) — decimal32 vs unsigned int.
bool operator!= (decimal32 __lhs, unsigned long __rhs) — decimal32 vs unsigned long.
bool operator!= (decimal32 __lhs, unsigned long long __rhs) — decimal32 vs unsigned long long.

and now decimal64 takes the wheel:

bool operator!= (decimal64 __lhs, decimal128 __rhs) — decimal64 vs decimal128.
bool operator!= (decimal64 __lhs, decimal32 __rhs) — decimal64 vs decimal32.
bool operator!= (decimal64 __lhs, decimal64 __rhs) — decimal64 vs decimal64.
bool operator!= (decimal64 __lhs, int __rhs) — decimal64 vs int.
bool operator!= (decimal64 __lhs, long __rhs) — decimal64 vs long.
bool operator!= (decimal64 __lhs, long long __rhs) — decimal64 vs long long.
bool operator!= (decimal64 __lhs, unsigned int __rhs) — decimal64 vs unsigned int.
bool operator!= (decimal64 __lhs, unsigned long __rhs) — decimal64 vs unsigned long.
bool operator!= (decimal64 __lhs, unsigned long long __rhs) — decimal64 vs unsigned long long.

flip it! integral type on the left, decimal on the right:

bool operator!= (int __lhs, decimal128 __rhs) — int vs decimal128.
bool operator!= (int __lhs, decimal32 __rhs) — int vs decimal32.
bool operator!= (int __lhs, decimal64 __rhs) — int vs decimal64.
bool operator!= (long __lhs, decimal128 __rhs) — long vs decimal128.
bool operator!= (long __lhs, decimal32 __rhs) — long vs decimal32.
bool operator!= (long __lhs, decimal64 __rhs) — long vs decimal64.
bool operator!= (long long __lhs, decimal128 __rhs) — long long vs decimal128.
bool operator!= (long long __lhs, decimal32 __rhs) — long long vs decimal32.
bool operator!= (long long __lhs, decimal64 __rhs) — long long vs decimal64.
bool operator!= (unsigned int __lhs, decimal128 __rhs) — unsigned int vs decimal128.
bool operator!= (unsigned int __lhs, decimal32 __rhs) — unsigned int vs decimal32.
bool operator!= (unsigned int __lhs, decimal64 __rhs) — unsigned int vs decimal64.
bool operator!= (unsigned long __lhs, decimal128 __rhs) — unsigned long vs decimal128.
bool operator!= (unsigned long __lhs, decimal32 __rhs) — unsigned long vs decimal32.
bool operator!= (unsigned long __lhs, decimal64 __rhs) — unsigned long vs decimal64.
bool operator!= (unsigned long long __lhs, decimal128 __rhs) — unsigned long long vs decimal128.
bool operator!= (unsigned long long __lhs, decimal32 __rhs) — unsigned long long vs decimal32.
bool operator!= (unsigned long long __lhs, decimal64 __rhs) — unsigned long long vs decimal64. done. that's all of them. breathe. 😮‍💨

🔥 `operator*` — multiply era

heads up: the return type is not always the biggest type. read the signature, bestie, it's right there. 👑

decimal128 operator* (decimal128 __lhs, decimal128 __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, decimal32 __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, decimal64 __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, int __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, long __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, long long __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, unsigned int __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, unsigned long __rhs) → decimal128
decimal128 operator* (decimal128 __lhs, unsigned long long __rhs) → decimal128
decimal128 operator* (decimal32 __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (decimal32 __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (decimal32 __lhs, decimal64 __rhs) → decimal64
decimal32 operator* (decimal32 __lhs, int __rhs) → decimal32
decimal32 operator* (decimal32 __lhs, long __rhs) → decimal32
decimal32 operator* (decimal32 __lhs, long long __rhs) → decimal32
decimal32 operator* (decimal32 __lhs, unsigned int __rhs) → decimal32
decimal32 operator* (decimal32 __lhs, unsigned long __rhs) → decimal32
decimal32 operator* (decimal32 __lhs, unsigned long long __rhs) → decimal32
decimal128 operator* (decimal64 __lhs, decimal128 __rhs) → decimal128
decimal64 operator* (decimal64 __lhs, decimal32 __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, decimal64 __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, int __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, long __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, long long __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, unsigned int __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, unsigned long __rhs) → decimal64
decimal64 operator* (decimal64 __lhs, unsigned long long __rhs) → decimal64
decimal128 operator* (int __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (int __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (int __lhs, decimal64 __rhs) → decimal64
decimal128 operator* (long __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (long __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (long __lhs, decimal64 __rhs) → decimal64
decimal128 operator* (long long __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (long long __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (long long __lhs, decimal64 __rhs) → decimal64
decimal128 operator* (unsigned int __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (unsigned int __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (unsigned int __lhs, decimal64 __rhs) → decimal64
decimal128 operator* (unsigned long __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (unsigned long __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (unsigned long __lhs, decimal64 __rhs) → decimal64
decimal128 operator* (unsigned long long __lhs, decimal128 __rhs) → decimal128
decimal32 operator* (unsigned long long __lhs, decimal32 __rhs) → decimal32
decimal64 operator* (unsigned long long __lhs, decimal64 __rhs) → decimal64

✨ `operator+` — add era (now with unary!!)

decimal128 operator+ (decimal128 __lhs, decimal128 __rhs)
decimal128 operator+ (decimal128 __lhs, decimal32 __rhs)
decimal128 operator+ (decimal128 __lhs, decimal64 __rhs)
decimal128 operator+ (decimal128 __lhs, int __rhs)
decimal128 operator+ (decimal128 __lhs, long __rhs)
decimal128 operator+ (decimal128 __lhs, long long __rhs)
decimal128 operator+ (decimal128 __lhs, unsigned int __rhs)
decimal128 operator+ (decimal128 __lhs, unsigned long __rhs)
decimal128 operator+ (decimal128 __lhs, unsigned long long __rhs)
decimal128 operator+ (decimal128 __rhs) — ⚠️ look, only one argument: this is the unary plus, and it returns decimal128.
decimal128 operator+ (decimal32 __lhs, decimal128 __rhs)
decimal32 operator+ (decimal32 __lhs, decimal32 __rhs)
decimal64 operator+ (decimal32 __lhs, decimal64 __rhs)
decimal32 operator+ (decimal32 __lhs, int __rhs)
decimal32 operator+ (decimal32 __lhs, long __rhs)
decimal32 operator+ (decimal32 __lhs, long long __rhs)
decimal32 operator+ (decimal32 __lhs, unsigned int __rhs)
decimal32 operator+ (decimal32 __lhs, unsigned long __rhs)
decimal32 operator+ (decimal32 __lhs, unsigned long long __rhs)
decimal32 operator+ (decimal32 __rhs) — unary plus again, this time decimal32.
decimal128 operator+ (decimal64 __lhs, decimal128 __rhs)
decimal64 operator+ (decimal64 __lhs, decimal32 __rhs)
decimal64 operator+ (decimal64 __lhs, decimal64 __rhs)
decimal64 operator+ (decimal64 __lhs, int __rhs)
decimal64 operator+ (decimal64 __lhs, long __rhs)
decimal64 operator+ (decimal64 __lhs, long long __rhs)
decimal64 operator+ (decimal64 __lhs, unsigned int __rhs)
decimal64 operator+ (decimal64 __lhs, unsigned long __rhs)
decimal64 operator+ (decimal64 __lhs, unsigned long long __rhs)
decimal64 operator+ (decimal64 __rhs) — third unary plus, decimal64 flavoured.
decimal128 operator+ (int __lhs, decimal128 __rhs)
decimal32 operator+ (int __lhs, decimal32 __rhs)
decimal64 operator+ (int __lhs, decimal64 __rhs)
decimal128 operator+ (long __lhs, decimal128 __rhs)
decimal32 operator+ (long __lhs, decimal32 __rhs)
decimal64 operator+ (long __lhs, decimal64 __rhs)
decimal128 operator+ (long long __lhs, decimal128 __rhs)
decimal32 operator+ (long long __lhs, decimal32 __rhs)
decimal64 operator+ (long long __lhs, decimal64 __rhs)
decimal128 operator+ (unsigned int __lhs, decimal128 __rhs)
decimal32 operator+ (unsigned int __lhs, decimal32 __rhs)
decimal64 operator+ (unsigned int __lhs, decimal64 __rhs)
decimal128 operator+ (unsigned long __lhs, decimal128 __rhs)
decimal32 operator+ (unsigned long __lhs, decimal32 __rhs)
decimal64 operator+ (unsigned long __lhs, decimal64 __rhs)
decimal128 operator+ (unsigned long long __lhs, decimal128 __rhs)
decimal32 operator+ (unsigned long long __lhs, decimal32 __rhs)
decimal64 operator+ (unsigned long long __lhs, decimal64 __rhs)

💜 `operator-` — subtraction era (unary minus said hi too)

decimal128 operator- (decimal128 __lhs, decimal128 __rhs)
decimal128 operator- (decimal128 __lhs, decimal32 __rhs)
decimal128 operator- (decimal128 __lhs, decimal64 __rhs)
decimal128 operator- (decimal128 __lhs, int __rhs)
decimal128 operator- (decimal128 __lhs, long __rhs)
decimal128 operator- (decimal128 __lhs, long long __rhs)
decimal128 operator- (decimal128 __lhs, unsigned int __rhs)
decimal128 operator- (decimal128 __lhs, unsigned long __rhs)
decimal128 operator- (decimal128 __lhs, unsigned long long __rhs)
decimal128 operator- (decimal128 __rhs) — unary minus, single arg, returns decimal128. negation slay.
decimal128 operator- (decimal32 __lhs, decimal128 __rhs)
decimal32 operator- (decimal32 __lhs, decimal32 __rhs)
decimal64 operator- (decimal32 __lhs, decimal64 __rhs)
decimal32 operator- (decimal32 __lhs, int __rhs)
decimal32 operator- (decimal32 __lhs, long __rhs)
decimal32 operator- (decimal32 __lhs, long long __rhs)
decimal32 operator- (decimal32 __lhs, unsigned int __rhs)
decimal32 operator- (decimal32 __lhs, unsigned long __rhs)
decimal32 operator- (decimal32 __lhs, unsigned long long __rhs)
decimal32 operator- (decimal32 __rhs) — unary minus for decimal32.
decimal128 operator- (decimal64 __lhs, decimal128 __rhs)
decimal64 operator- (decimal64 __lhs, decimal32 __rhs)
decimal64 operator- (decimal64 __lhs, decimal64 __rhs)
decimal64 operator- (decimal64 __lhs, int __rhs)
decimal64 operator- (decimal64 __lhs, long __rhs)
decimal64 operator- (decimal64 __lhs, long long __rhs)
decimal64 operator- (decimal64 __lhs, unsigned int __rhs)

okay so we're picking up mid-roster on operator- — the minus squad continues, and yes every single one of these bad boys gets its own line 💅

decimal64 operator- (decimal64 __lhs, unsigned long __rhs)
decimal64 operator- (decimal64 __lhs, unsigned long long __rhs)
decimal64 operator- (decimal64 __rhs)
decimal128 operator- (int __lhs, decimal128 __rhs)
decimal32 operator- (int __lhs, decimal32 __rhs)
decimal64 operator- (int __lhs, decimal64 __rhs)
decimal128 operator- (long __lhs, decimal128 __rhs)
decimal32 operator- (long __lhs, decimal32 __rhs)
decimal64 operator- (long __lhs, decimal64 __rhs)
decimal128 operator- (long long __lhs, decimal128 __rhs)
decimal32 operator- (long long __lhs, decimal32 __rhs)
decimal64 operator- (long long __lhs, decimal64 __rhs)
decimal128 operator- (unsigned int __lhs, decimal128 __rhs)
decimal32 operator- (unsigned int __lhs, decimal32 __rhs)
decimal64 operator- (unsigned int __lhs, decimal64 __rhs)
decimal128 operator- (unsigned long __lhs, decimal128 __rhs)
decimal32 operator- (unsigned long __lhs, decimal32 __rhs)
decimal64 operator- (unsigned long __lhs, decimal64 __rhs)
decimal128 operator- (unsigned long long __lhs, decimal128 __rhs)
decimal32 operator- (unsigned long long __lhs, decimal32 __rhs)
decimal64 operator- (unsigned long long __lhs, decimal64 __rhs)

spotted the icon: decimal64 operator- (decimal64 __rhs) is the unary one — single argument, no __lhs, she's out here doing straight-up negation all by herself 🫶

and that's the whole minus family, wrapped and done. periodt.

next up: division ✨ the operator/ set is thicc — big main character energy, nine whole lines just for decimal128 on the left alone. here she is 💖

decimal128 operator/ (decimal128 __lhs, decimal128 __rhs)
decimal128 operator/ (decimal128 __lhs, decimal32 __rhs)
decimal128 operator/ (decimal128 __lhs, decimal64 __rhs)
decimal128 operator/ (decimal128 __lhs, int __rhs)
decimal128 operator/ (decimal128 __lhs, long __rhs)
decimal128 operator/ (decimal128 __lhs, long long __rhs)
decimal128 operator/ (decimal128 __lhs, unsigned int __rhs)
decimal128 operator/ (decimal128 __lhs, unsigned long __rhs)
decimal128 operator/ (decimal128 __lhs, unsigned long long __rhs)
decimal128 operator/ (decimal32 __lhs, decimal128 __rhs)
decimal32 operator/ (decimal32 __lhs, decimal32 __rhs)
decimal64 operator/ (decimal32 __lhs, decimal64 __rhs)
decimal32 operator/ (decimal32 __lhs, int __rhs)
decimal32 operator/ (decimal32 __lhs, long __rhs)
decimal32 operator/ (decimal32 __lhs, long long __rhs)
decimal32 operator/ (decimal32 __lhs, unsigned int __rhs)
decimal32 operator/ (decimal32 __lhs, unsigned long __rhs)
decimal32 operator/ (decimal32 __lhs, unsigned long long __rhs)
decimal128 operator/ (decimal64 __lhs, decimal128 __rhs)
decimal64 operator/ (decimal64 __lhs, decimal32 __rhs)
decimal64 operator/ (decimal64 __lhs, decimal64 __rhs)
decimal64 operator/ (decimal64 __lhs, int __rhs)
decimal64 operator/ (decimal64 __lhs, long __rhs)
decimal64 operator/ (decimal64 __lhs, long long __rhs)
decimal64 operator/ (decimal64 __lhs, unsigned int __rhs)
decimal64 operator/ (decimal64 __lhs, unsigned long __rhs)
decimal64 operator/ (decimal64 __lhs, unsigned long long __rhs)
decimal128 operator/ (int __lhs, decimal128 __rhs)
decimal32 operator/ (int __lhs, decimal32 __rhs)
decimal64 operator/ (int __lhs, decimal64 __rhs)
decimal128 operator/ (long __lhs, decimal128 __rhs)
decimal32 operator/ (long __lhs, decimal32 __rhs)
decimal64 operator/ (long __lhs, decimal64 __rhs)
decimal128 operator/ (long long __lhs, decimal128 __rhs)
decimal32 operator/ (long long __lhs, decimal32 __rhs)
decimal64 operator/ (long long __lhs, decimal64 __rhs)
decimal128 operator/ (unsigned int __lhs, decimal128 __rhs)
decimal32 operator/ (unsigned int __lhs, decimal32 __rhs)
decimal64 operator/ (unsigned int __lhs, decimal64 __rhs)
decimal128 operator/ (unsigned long __lhs, decimal128 __rhs)
decimal32 operator/ (unsigned long __lhs, decimal32 __rhs)
decimal64 operator/ (unsigned long __lhs, decimal64 __rhs)
decimal128 operator/ (unsigned long long __lhs, decimal128 __rhs)
decimal32 operator/ (unsigned long long __lhs, decimal32 __rhs)
decimal64 operator/ (unsigned long long __lhs, decimal64 __rhs)

ngl bestie, look at that return-type glow-up: when the two sides don't match, the answer levels up to the bigger of the two — decimal32 ÷ decimal64 gives you a decimal64, decimal32 ÷ decimal128 gives you a decimal128, decimal64 ÷ decimal128 gives you a decimal128. and when both sides are the same type? you get that type right back. the way it just scales 😭👑

comparison time babes 🌈 operator< returns a good ol' bool — no decimal nonsense, just yes-or-no, true-or-false, ate-or-didn't 💀

bool operator< (decimal128 __lhs, decimal128 __rhs)
bool operator< (decimal128 __lhs, decimal32 __rhs)
bool operator< (decimal128 __lhs, decimal64 __rhs)
bool operator< (decimal128 __lhs, int __rhs)
bool operator< (decimal128 __lhs, long __rhs)
bool operator< (decimal128 __lhs, long long __rhs)
bool operator< (decimal128 __lhs, unsigned int __rhs)
bool operator< (decimal128 __lhs, unsigned long __rhs)
bool operator< (decimal128 __lhs, unsigned long long __rhs)
bool operator< (decimal32 __lhs, decimal128 __rhs)
bool operator< (decimal32 __lhs, decimal32 __rhs)
bool operator< (decimal32 __lhs, decimal64 __rhs)
bool operator< (decimal32 __lhs, int __rhs)
bool operator< (decimal32 __lhs, long __rhs)
bool operator< (decimal32 __lhs, long long __rhs)
bool operator< (decimal32 __lhs, unsigned int __rhs)
bool operator< (decimal32 __lhs, unsigned long __rhs)
bool operator< (decimal32 __lhs, unsigned long long __rhs)
bool operator< (decimal64 __lhs, decimal128 __rhs)
bool operator< (decimal64 __lhs, decimal32 __rhs)
bool operator< (decimal64 __lhs, decimal64 __rhs)
bool operator< (decimal64 __lhs, int __rhs)
bool operator< (decimal64 __lhs, long __rhs)
bool operator< (decimal64 __lhs, long long __rhs)
bool operator< (decimal64 __lhs, unsigned int __rhs)
bool operator< (decimal64 __lhs, unsigned long __rhs)
bool operator< (decimal64 __lhs, unsigned long long __rhs)
bool operator< (int __lhs, decimal128 __rhs)
bool operator< (int __lhs, decimal32 __rhs)
bool operator< (int __lhs, decimal64 __rhs)
bool operator< (long __lhs, decimal128 __rhs)
bool operator< (long __lhs, decimal32 __rhs)
bool operator< (long __lhs, decimal64 __rhs)
bool operator< (long long __lhs, decimal128 __rhs)
bool operator< (long long __lhs, decimal32 __rhs)
bool operator< (long long __lhs, decimal64 __rhs)
bool operator< (unsigned int __lhs, decimal128 __rhs)
bool operator< (unsigned int __lhs, decimal32 __rhs)
bool operator< (unsigned int __lhs, decimal64 __rhs)
bool operator< (unsigned long __lhs, decimal128 __rhs)
bool operator< (unsigned long __lhs, decimal32 __rhs)
bool operator< (unsigned long __lhs, decimal64 __rhs)
bool operator< (unsigned long long __lhs, decimal128 __rhs)
bool operator< (unsigned long long __lhs, decimal32 __rhs)
bool operator< (unsigned long long __lhs, decimal64 __rhs)

notice it goes both directions — int on the left with a decimal on the right and decimal on the left with int on the right, because the compiler doesn't know which one you meant and honestly? she's just being polite 💅

and now the equality girlies 🎀 operator==, same bool return, same exhaustive energy, same 45 lines of "what if it's this type tho":

bool operator== (decimal128 __lhs, decimal128 __rhs)
bool operator== (decimal128 __lhs, decimal32 __rhs)
bool operator== (decimal128 __lhs, decimal64 __rhs)
bool operator== (decimal128 __lhs, int __rhs)
bool operator== (decimal128 __lhs, long __rhs)
bool operator== (decimal128 __lhs, long long __rhs)
bool operator== (decimal128 __lhs, unsigned int __rhs)
bool operator== (decimal128 __lhs, unsigned long __rhs)
bool operator== (decimal128 __lhs, unsigned long long __rhs)
bool operator== (decimal32 __lhs, decimal128 __rhs)
bool operator== (decimal32 __lhs, decimal32 __rhs)
bool operator== (decimal32 __lhs, decimal64 __rhs)
bool operator== (decimal32 __lhs, int __rhs)
bool operator== (decimal32 __lhs, long __rhs)
bool operator== (decimal32 __lhs, long long __rhs)
bool operator== (decimal32 __lhs, unsigned int __rhs)
bool operator== (decimal32 __lhs, unsigned long __rhs)
bool operator== (decimal32 __lhs, unsigned long long __rhs)
bool operator== (decimal64 __lhs, decimal128 __rhs)
bool operator== (decimal64 __lhs, decimal32 __rhs)
bool operator== (decimal64 __lhs, decimal64 __rhs)
bool operator== (decimal64 __lhs, int __rhs)
bool operator== (decimal64 __lhs, long __rhs)
bool operator== (decimal64 __lhs, long long __rhs)
bool operator== (decimal64 __lhs, unsigned int __rhs)
bool operator== (decimal64 __lhs, unsigned long __rhs)
bool operator== (decimal64 __lhs, unsigned long long __rhs)
bool operator== (int __lhs, decimal128 __rhs)
bool operator== (int __lhs, decimal32 __rhs)
bool operator== (int __lhs, decimal64 __rhs)
bool operator== (long __lhs, decimal128 __rhs)
bool operator== (long __lhs, decimal32 __rhs)
bool operator== (long __lhs, decimal64 __rhs)
bool operator== (long long __lhs, decimal128 __rhs)
bool operator== (long long __lhs, decimal32 __rhs)
bool operator== (long long __lhs, decimal64 __rhs)
bool operator== (unsigned int __lhs, decimal128 __rhs)
bool operator== (unsigned int __lhs, decimal32 __rhs)
bool operator== (unsigned int __lhs, decimal64 __rhs)
bool operator== (unsigned long __lhs, decimal128 __rhs)
bool operator== (unsigned long __lhs, decimal32 __rhs)
bool operator== (unsigned long __lhs, decimal64 __rhs)
bool operator== (unsigned long long __lhs, decimal128 __rhs)
bool operator== (unsigned long long __lhs, decimal32 __rhs)
bool operator== (unsigned long long __lhs, decimal64 __rhs)

and we're ending this part on operator> ⭐ — the "greater than" crew, doing the exact same dance as < except the other way around. she's mid-roll call so don't go anywhere 🙈

bool operator> (decimal128 __lhs, decimal128 __rhs)
bool operator> (decimal128 __lhs, decimal32 __rhs)
bool operator> (decimal128 __lhs, decimal64 __rhs)
bool operator> (decimal128 __lhs, int __rhs)
bool operator> (decimal128 __lhs, long __rhs)
bool operator> (decimal128 __lhs, long long __rhs)
bool operator> (decimal128 __lhs, unsigned int __rhs)
bool operator> (decimal128 __lhs, unsigned long __rhs)
bool operator> (decimal128 __lhs, unsigned long long __rhs)
bool operator> (decimal32 __lhs, decimal128 __rhs)
bool operator> (decimal32 __lhs, decimal32 __rhs)
bool operator> (decimal32 __lhs, decimal64 __rhs)
bool operator> (decimal32 __lhs, int __rhs)
bool operator> (decimal32 __lhs, long __rhs)
bool operator> (decimal32 __lhs, long long __rhs)
bool operator> (decimal32 __lhs, unsigned int __rhs)
bool operator> (decimal32 __lhs, unsigned long __rhs)
bool operator> (decimal32 __lhs, unsigned long long __rhs)
bool operator> (decimal64 __lhs, decimal128 __rhs)
bool operator> (decimal64 __lhs, decimal32 __rhs)
bool operator> (decimal64 __lhs, decimal64 __rhs)
bool operator> (decimal64 __lhs, int __rhs)
bool operator> (decimal64 __lhs, long __rhs)
bool operator> (decimal64 __lhs, long long __rhs)
bool operator> (decimal64 __lhs, unsigned int __rhs)
bool operator> (decimal64 __lhs, unsigned long __rhs)
bool operator> (decimal64 __lhs, unsigned long long __rhs)
bool operator> (int __lhs, decimal128 __rhs)
bool operator> (int __lhs, decimal32 __rhs)
bool operator> (int __lhs, decimal64 __rhs)
bool operator> (long __lhs, decimal128 __rhs)
bool operator> (long __lhs, decimal32 __rhs)
bool operator> (long __lhs, decimal64 __rhs)
bool operator> (long long __lhs, decimal128 __rhs)
bool operator> (long long __lhs, decimal32 __rhs)
bool operator> (long long __lhs, decimal64 __rhs)
bool operator> (unsigned int __lhs, decimal128 __rhs)
bool operator> (unsigned int __lhs, decimal32 __rhs)
bool operator> (unsigned int __lhs, decimal64 __rhs)
bool operator> (unsigned long __lhs, decimal128 __rhs)
bool operator> (unsigned long __lhs, decimal32 __rhs)
bool operator> (unsigned long __lhs, decimal64 __rhs)
bool operator> (unsigned long long __lhs, decimal128 __rhs)
bool operator> (unsigned long long __lhs, decimal32 __rhs)

still rolling, bestie — more coming 💖

...and bestie, we are SO close to the end of this operator wall. Like, we've been scrolling for hours and my thumbs hurt, but the >= squad deserves its moment too, okay? One straggler > first (fashionably late, honestly iconic of it), then every single >= pairing in existence. No cap, they really did type out all of them:

bool operator> (unsigned long long __lhs, decimal64 __rhs)
bool operator>= (decimal128 __lhs, decimal128 __rhs)
bool operator>= (decimal128 __lhs, decimal32 __rhs)
bool operator>= (decimal128 __lhs, decimal64 __rhs)
bool operator>= (decimal128 __lhs, int __rhs)
bool operator>= (decimal128 __lhs, long __rhs)
bool operator>= (decimal128 __lhs, long long __rhs)
bool operator>= (decimal128 __lhs, unsigned int __rhs)
bool operator>= (decimal128 __lhs, unsigned long __rhs)
bool operator>= (decimal128 __lhs, unsigned long long __rhs)
bool operator>= (decimal32 __lhs, decimal128 __rhs)
bool operator>= (decimal32 __lhs, decimal32 __rhs)
bool operator>= (decimal32 __lhs, decimal64 __rhs)
bool operator>= (decimal32 __lhs, int __rhs)
bool operator>= (decimal32 __lhs, long __rhs)
bool operator>= (decimal32 __lhs, long long __rhs)
bool operator>= (decimal32 __lhs, unsigned int __rhs)
bool operator>= (decimal32 __lhs, unsigned long __rhs)
bool operator>= (decimal32 __lhs, unsigned long long __rhs)
bool operator>= (decimal64 __lhs, decimal128 __rhs)
bool operator>= (decimal64 __lhs, decimal32 __rhs)
bool operator>= (decimal64 __lhs, decimal64 __rhs)
bool operator>= (decimal64 __lhs, int __rhs)
bool operator>= (decimal64 __lhs, long __rhs)
bool operator>= (decimal64 __lhs, long long __rhs)
bool operator>= (decimal64 __lhs, unsigned int __rhs)
bool operator>= (decimal64 __lhs, unsigned long __rhs)
bool operator>= (decimal64 __lhs, unsigned long long __rhs)
bool operator>= (int __lhs, decimal128 __rhs)
bool operator>= (int __lhs, decimal32 __rhs)
bool operator>= (int __lhs, decimal64 __rhs)
bool operator>= (long __lhs, decimal128 __rhs)
bool operator>= (long __lhs, decimal32 __rhs)
bool operator>= (long __lhs, decimal64 __rhs)
bool operator>= (long long __lhs, decimal128 __rhs)
bool operator>= (long long __lhs, decimal32 __rhs)
bool operator>= (long long __lhs, decimal64 __rhs)
bool operator>= (unsigned int __lhs, decimal128 __rhs)
bool operator>= (unsigned int __lhs, decimal32 __rhs)
bool operator>= (unsigned int __lhs, decimal64 __rhs)
bool operator>= (unsigned long __lhs, decimal128 __rhs)
bool operator>= (unsigned long __lhs, decimal32 __rhs)
bool operator>= (unsigned long __lhs, decimal64 __rhs)
bool operator>= (unsigned long long __lhs, decimal128 __rhs)
bool operator>= (unsigned long long __lhs, decimal32 __rhs)
bool operator>= (unsigned long long __lhs, decimal64 __rhs)

Right?? Every decimal32 / decimal64 / decimal128 combo with each other, and with int, long, long long, unsigned int, unsigned long, unsigned long long — both directions, __lhs and __rhs — and every single one hands you back a bool. It's giving "we will not let you write a comparison that doesn't compile." Obsessed. 🔥

🦋 DETAILED DESCRIPTION 🦋

ISO/IEC TR 24733 Decimal floating-point arithmetic.

That's the whole vibe, bestie — this whole header is the implementation of that ISO/IEC TR 24733 decimal floating-point arithmetic spec. That's the standard, that's the assignment, that's the moment. ✨

🌈 FUNCTION DOCUMENTATION 🌈

🎀 `long long std::decimal::decimal32_to_long_long (decimal32 __d)`

K so this one is a non-conforming extension — meaning it's a little bonus the library hands you that's not part of the conforming spec. Read that again, because I need you to know it before you build your whole personality on it: non-conforming extension. It does a conversion to integral type.

References: std::operator+(), and std::operator-(). Those are the two it name-drops, so write them down in your notes app alongside your crush's birthday. 📝💖

👑 AUTHOR 👑

Generated automatically by Doxygen for libstdc++ from the source code.

I know. Nobody hand-wrote this masterpiece — the robot did it, and honestly? Slay, little Doxygen. 💅

And that's a wrap on std::decimal(3cxx), bestie!! Courtesy of libstdc++ and its humble servant Doxygen, filed under section 3cxx in your friendly neighborhood man pages. Go forth and compare decimals responsibly. 🫶🍓💜

📦 where this page comes from

ubuntu noble: libstdc++-14-doc 14-20240412-0ubuntu1
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-06: a language model's rewrite of the original, under its terms