bdldfp_decimal.h

// bdldfp_decimal.h                                                   -*-C++-*-
#ifndef INCLUDED_BDLDFP_DECIMAL
#define INCLUDED_BDLDFP_DECIMAL

#include <bsls_ident.h>
BSLS_IDENT("$Id$")

//@PURPOSE: Provide IEEE-754 decimal floating-point types.
//
//@CLASSES:
//  bdldfp::Decimal32:   32bit IEEE-754 decimal floating-point type
//  bdldfp::Decimal64:   64bit IEEE-754 decimal floating-point type
//  bdldfp::Decimal128: 128bit IEEE-754 decimal floating-point type
//  bdldfp::DecimalNumGet: Stream Input Facet
//  bdldfp::DecimalNumPut: Stream Output Facet
//
//@MACROS:
//  BDLDFP_DECIMAL_DF: Portable Decimal32 literal macro
//  BDLDFP_DECIMAL_DD: Portable Decimal64 literal macro
//  BDLDFP_DECIMAL_DL: Portable Decimal128 literal macro
//
//@SEE_ALSO: bdldfp_decimalutil, bdldfp_decimalconvertutil,
//           bdldfp_decimalplatform
//
//@DESCRIPTION: This component provides classes that implement decimal
// floating-point types that conform in layout, encoding and operations to the
// IEEE-754 2008 standard.  This component also provides two facets to support
// standard C++ streaming operators as specified by ISO/IEC TR-24733:2009.
// These classes are 'bdldfp::Decimal32' for 32-bit Decimal floating point
// numbers, 'bdldfp::Decimal64' for 64-bit Decimal floating point numbers, and
// 'bdldfp::Decimal128' for 128-bit decimal floating point numbers.
//
// Decimal encoded floating-point numbers are important where exact
// representation of decimal fractions is required, such as in financial
// transactions.  Binary encoded floating-point numbers are generally optimal
// for complex computation but cannot exactly represent commonly encountered
// numbers such as 0.1, 0.2, and 0.99.
//
// NOTE: Interconversion between binary and decimal floating-point values is
// fraught with misunderstanding and must be done carefully and with intent,
// taking into account the provenance of the data.  See the discussion on
// conversion below and in the 'bdldfp_decimalconvertutil' component.
//
// The BDE decimal floating-point system has been designed from the ground up
// to be portable and support writing portable decimal floating-point user
// code, even for systems that do not have compiler or native library support
// for it; while taking advantage of native support (such as ISO/IEC TR
// 24732 - C99 decimal TR) when available.
//
// 'bdldfp::DecimalNumGet' and 'bdldfp::DecimalNumPut' are IO stream facets.
//
///Floating-Point Primer
///---------------------
// There are several ways of represent numbers when using digital computers.
// The simplest would be an integer format, however such a format severely
// limits the range of numbers that can be represented; and it cannot represent
// real (non-integer) numbers directly at all.  Integers might be used to
// represent real numbers of limited precision by treating them as a multiple
// of the real value being represented; these are often known as fixed-point
// numbers.  However general computations require higher precision and a larger
// range than integer and fixed point types are able to efficiently provide.
// Floating-point numbers provide what integers cannot.  They are able to
// represent a large range of real values (although not precisely) while using
// a fixed (and reasonable) amount of storage.
//
// Floating-point numbers are constructed from a set of significant digits of a
// radix on a sliding scale, where their position is determined by an exponent
// over the same radix.  For example let's see some 32bit decimal (radix 10)
// floating-point numbers that have maximum 7 significant digits (significand):
//..
//   Significand | Exponent | Value        |
//  -------------+----------+--------------+  In the Value column you may
//       1234567 |        0 |   1234567.0  |  observer how the decimal point
//       1234567 |        1 |  12345670.0  |  is "floating" about the digits
//       1234567 |        2 | 123456700.0  |  of the significand.
//       1234567 |       -1 |    123456.7  |
//       1234567 |       -2 |     12345.67 |
//..
// Floating-point numbers are standardized by IEEE-754 2008, in two major
// flavors: binary and decimal.  Binary floating-point numbers are supported by
// most computer systems in the forms of the 'float', 'double' and
// 'long double' fundamental data types.  While they are not required to be
// binary that is almost always the choice on modern binary computer
// architectures.
//
///Floating-Point Peculiarities
/// - - - - - - - - - - - - - -
// Floating-point approximation of real numbers creates a deliberate illusion.
// While it looks like we are working with real numbers, floating-point
// encodings are not able to represent real numbers precisely since they have a
// restricted number of digits in the significand.  In fact, a 64 bit
// floating-point type can represent fewer distinct values than a 64 bit binary
// integer.  Yet, because floating-point encodings can represent numbers over a
// much larger range, including extremely small (fractional) numbers, they are
// useful in practice.
//
// Floating-point peculiarities may be split into three categories: those that
// are due to the (binary) radix/base, those that are inherent properties of
// any floating-point representation and finally those that are introduced by
// the IEEE-754 2008 standard.  Decimal floating-point addresses the first set
// of surprises only; so users still need to be aware of the rest.
//
//: 1 Floating-point types cannot exactly represent every number in their
//:   range.  The consequences are surprising and unexpected for the newcomer.
//:   For example: when using binary floating-point numbers, the following
//:   expression is typically *false*: '0.1 + 0.2 == 0.3'.  The problem is not
//:   limited to binary floating-point.  Decimal floating-point cannot
//:   represent the value of one third exactly.
//:
//: 2 Unlike with real numbers, the order of operations on floating-point
//:   numbers is significant, due to accumulation of round off errors.
//:   Therefore floating-point arithmetic is neither commutative nor
//:   transitive.  E.g., 2e-30 + 1e30 - 1e-30 - 1e30 will typically produce 0
//:   (unless your significand can hold 60 decimal digits).  Alternatively,
//:   1e30 - 1e30 + 2e-30 - 1e-30 will typically produce 1e-30.
//:
//: 3 IEEE floating-point types can have special values: negative zero,
//:   negative and positive infinity; and they can be NaN (Not a Number, in two
//:   variants: quiet or signaling).  A NaN (any variant) is never equal to
//:   anything else - including NaN or itself!
//:
//: 4 In IEEE floating-point there are at least two representations of 0, the
//:   positive zero and negative zero.  Consequently unary - operators change
//:   the sign of the value 0; therefore leading to surprising results: if
//:   'f == 0.0' then '0 - f' and '-f' will not result in the same value,
//:   because '0 - f' will be +0.0' while '-f' will be -0.0.
//:
//: 5 Most IEEE floating-point operations (like arithmetic) have implicit input
//:   parameters and output parameters (that do not show up in function
//:   signatures.  The implicit input parameters are called *attributes* by
//:   IEEE while the outputs are called status flags.  The C/C++ programming
//:   language defines a so-called floating-point environment that contains
//:   those attributes and flags ('<fenv.h>' C and '<cfenv>' C++ headers).  To
//:   learn more about the floating point environment read the subsection of
//:   the same title, but first make sure you read the next point as well.
//:
//: 6 IEEE floating-points overloads some very common programming language
//:   terms: *exception*, *signal* and *handler* with IEEE floating-point
//:   specific meanings that are not to be confused with C or C++ or Posix
//:   terms of the same spelling.  Floating-point exceptions are events that
//:   occur when a floating-point operations on the specified operands is
//:   unable to produce a perfect outcome; such as when the result of an
//:   operation is inexact.  When a floating point exception occurs the
//:   (floating-point) - and reporting it is requested by a so-called trap
//:   attribute - the implementation signals the user(*) by invoking a default
//:   or a user-defined handler.  None of the words *exception*, *signal*, and
//:   *handler* used above have nothing to do with C++ exceptions, Posix
//:   signals and the handlers of those.  (To complicate matters more, C and
//:   Posix has decided to implement IEEE floating-point exception reporting as
//:   C/Posix signals - and therefore rendered them mostly useless.)
//:
//: 7 While a 32bit integer is a quite useful type for (integer) calculations,
//:   a 32bit floating-point type has such low accuracy (its significand is so
//:   short) that it is all but useless for calculation.  Such types are called
//:   "interchange formats" by the IEEE standard and should not be used for
//:   calculations.  (Except in special circumstances and by floating-point
//:   experts.  Even a 16 bit binary floating-point type can be useful for an
//:   expert in special circumstances, for example in graphics acceleration
//:   hardware.)
//
// Notes:
//   (*) IEEE Floating-point user is any person, hardware or software that uses
//       the IEEE floating-point implementation.
//
///Floating-Point Environment
/// - - - - - - - - - - - - -
// NOTE: We currently do not give access to the user to the floating-point
// environment used by our decimal system, so description of it here is
// preliminary and generic.  Note that since compilers and the C library
// already provides a (possibly binary floating-point only) environment and we
// cannot change that, our decimal floating-point environment implementation
// cannot conform to the C and C++ TRs (because those require extending the
// existing standard C library functions).
//
// The floating-point environment provides implicit input and output parameters
// to floating-point operations (that are defined to use them).  IEEE defined
// those parameters in principle, but how they are provided is left up to be
// designed/defined by the implementors of the programming languages.
//
// C (and consequently C++) decided to provide a so-called floating-point
// environment that has "thread storage duration", meaning that each thread of
// a multi-threaded program will have its own distinct floating-point
// environment.
//
// The C/C++ floating-point environment consists of 3 major parts: the rounding
// mode, the traps and the status flags.
//
///Rounding Direction in The Environment
///-  -  -  -  -  -  -  -  -  -  -  -  -
// A floating-point *rounding direction* determines how is the significand of a
// higher (or infinite) precision number get rounded to fit into the limited
// number of significant digits (significand) of the floating-point
// representation that needs to store it as a result of an operation.  Note
// that the rounding is done in the radix of the representation, so binary
// floating-point will do binary rounding while decimal floating-point will do
// decimal rounding - and not all rounding modes are useful with all radixes.
// An example of a generally applicable rounding mode would be 'FE_TOWARDZERO'
// (round towards zero).
//
// Most floating point operations in C and C++ do not take a rounding direction
// parameter (and the ones that are implemented as operators simply could not).
// When such operations (that do not have an explicit rounding direction
// parameter) need to do rounding, they use the rounding direction set in the
// floating-point environment (of their thread of execution).
//
///Status Flags
///  -  -  -  -
// Floating point operations in C and C++ do not take a status flag output
// parameter.  They report an important events (such as underflow, overflow or
// in inexact (rounded) result) by setting the appropriate status flag in the
// floating-point environment (of their thread of execution).  (Note that this
// is very similar to how flags work in CPUs, and that is not a coincidence.)
// The flags work much like individual, boolean 'errno' values.  Operations may
// set them to true.  Users may examine them (when interested) and also reset
// them (set them to 0) before an operation.
//
///Floating-Point Traps
/// -  -  -  -  -  -  -
// IEEE says that certain floating-point events are floating-point exceptions
// and they result in invoking a handler.  It may be a default handler (set a
// status flag and continue) or a user defined handler.  Floating point traps
// are a C invention to enable "sort-of handlers" for floating point
// exceptions, but unfortunately they all go to the same handler: the 'SIGFPE'
// handler.  To add insult to injury, setting what traps are active (what will)
// cause a 'SIGFPE') is not standardized.  So floating-point exceptions and
// handlers are considered pretty much useless in C.  (All is not lost, since
// we do have the status flags.  An application that wants to know about
// floating-point events can clear the flags prior to an operation and check
// their values afterwards.)
//
/// Error Reporting
///-  -  -  -  -  -
// The 'bdldfp_decimalutil' utility component provides a set of decimal math
// functions that parallel those provided for binary floating point in the C++
// standard math library.  Errors during computation of these functions (e.g.,
// domain errors) will be reported through the setting of 'errno' as described
// in the "Status Flags" section above.  (Note that this method of reporting
// errors is atypical for BDE-provided interfaces, but matches the style used
// by the standard functions.)
//
///Floating-Point Terminology
/// - - - - - - - - - - - - -
// A floating-point representation of a number is defined as follows:
// 'sign * significand * BASE^exponent', where sign is -1 or +1, significand is
// an integer, BASE is a positive integer (but usually 2 or 10) and exponent is
// a negative or positive integer.  Concrete examples of (decimal) numbers in
// the so-called scientific notation are: 123.4567 is 1.234567e2, while
// -0.000000000000000000000000000000000000001234567 would be -1.234567e-41.
//
//: "base":
//:    the number base of the scaling used by the exponent; and by the
//:    significand
//:
//: "bias":
//:    the number added to the exponent before it is stored in memory; 101, 398
//:    and 6176 for the 32, 64 and 128 bit types respectively.
//:
//: "exponent":
//:    the scaling applied to the significand is calculated by raising the base
//:    to the exponent (which may be also negative)
//:
//: "quantum":
//:     (IEEE-754) the value of one unit at the last significant digit
//:     position; in other words the smallest difference that can be
//:     represented by a floating-point number without changing its exponent.
//:
//: "mantissa":
//:    the old name for the significand
//:
//: "radix":
//:    another name for base
//:
//: "sign":
//:    +1 or -1, determines if the number is positive or negative.  It is
//:    normally represented by a single sign bit.
//:
//: "significand":
//:    the significant digits of the floating-point number; the value of the
//:    number is: 'sign * significand * base^exponent'
//:
//: "precision":
//:    the significant digits of the floating-point type in its base
//:
//: "decimal precision":
//:    the maximum significant decimal digits of the floating-point type
//:
//: "range":
//:    the smallest and largest number the type can represent.  Note that for
//:    floating-point types there are at least *two* interpretations of
//:    minimum.  It may be the largest negative number *or* the smallest number
//:    in absolute value) that can be represented.
//:
//: "normalized number":
//:    '1 <= significand <= base'
//:
//: "normalization":
//:    finding the exponent such as '1 <= significand <= base'
//:
//: "denormal number":
//:    'significand < 1'
//:
//: "densely packed decimal":
//:    one of the two IEEE significand encoding schemes
//:
//: "binary integer significand":
//:    one of the two IEEE significand encoding schemes
//:
//: "cohorts":
//:    equal numbers encoded using different exponents (to signify accuracy)
//
///Decimal Floating-Point
///----------------------
// Binary floating-point formats give best accuracy, they are the fastest (on
// binary computers), and were carefully designed by IEEE to minimize rounding
// errors (errors due to the inherent imprecision of floating-point types)
// during a lengthy calculation.  This makes them the best solution for and
// serious scientific computation.  However, they have a fatal flow when it
// comes to numbers and calculations that involve humans.  Humans think in base
// 10 - decimal.  And as the example has shown earlier, binary floating-point
// formats are unable to precisely represent very common decimal real numbers;
// with binary floating-point '0.1 + 0.2 != 0.3'.  (Why?  Because none of the
// three numbers in that expression have an exact binary floating-point
// representation.)
//
// Financial calculations are governed by laws and expectations that are based
// on decimal (10 based) thinking.  Due to the inherent limitations of the
// binary floating-point format, doing such decimal based calculations and
// algorithms using binary floating-point numbers is so involved and hard that
// that it is considered not feasible.  The IEEE-754 committee have recognized
// the issue and added specifications for 3 decimal floating-point types into
// their 2008 standard: the 32, 64 and 128 bits decimal floating-point formats.
//
// Floating-point types are carefully designed trade-offs between saving space
// (in memory), CPU cycles (for calculations) and still provide useful accuracy
// for computations.  Decimal floating-point types represent further
// compromises (compared to binary floating-points) in being able to represent
// less numbers (than their binary counterparts) and being slower, but
// providing exact representations for the numbers humans care about.
//
// In decimal floating-point world '0.1 + 0.2 == 0.3', as humans expect;
// because each of those 3 numbers can be represented *exactly* in a decimal
// floating-point format.
//
///*WARNING*: Conversions from 'float' and 'double'
/// - - - - - - - - - - - - - - - - - - - - - - - -
// Clients should *be* *careful* when using the conversions from 'float' and
// 'double' provided by this component.  In situations where a 'float' or
// 'double' was originally obtained from a decimal floating point
// representation (e.g., a 'bdldfp::Decimal', or a string, like "4.1"), the
// conversions in 'bdldfp_decimalconvertutil' will provide the correct
// conversion back to a decimal floating point value.  The conversions in this
// component provide the closest decimal floating point value to the supplied
// binary floating point representation, which may replicate imprecisions
// required to initially approximate the value in a binary representation.
// The conversions in this component are typically useful when converting
// binary floating point values that have undergone mathematical operations
// that require rounding (so they are already in-exact approximations).
//
///Cohorts
///- - - -
// In the binary floating-point world the formats are optimized for the highest
// precision, range and speed.  They are stored normalized and therefore store
// no information about their accuracy.  In finances, the area that decimal
// floating-point types target, accuracy of a number is usually very important.
// We may have a number that is 1, but we know it may be 1.001 or 1.002 etc.
// And we may have another number 1, which we know to be accurate to 6
// significant digits.  We would display the former number as '1.00' and the
// latter number as '1.00000'.  The decimal floating-point types are able to
// store both numbers *and* their precision using so called cohorts.  The
// '1.00' will be stored as '100e-2' while '1.00000' will be stored as
// '100000e-5'.
//
// Cohorts compare equal, and mostly behave the same way in calculation except
// when it comes to the accuracy of the result.  If I have a number that is
// accurate to 5 digits only, it would be a mistake to try to expect more than
// 5 digits accuracy from a calculation involving it.  The IEEE-754 rules of
// cohorts (in calculations) ensures that results will be a cohort that
// indicates the proper expected accuracy.
//
///Standards Conformance
///---------------------
// The component has also been designed to resemble the C++ Decimal
// Floating-Point Technical Report ISO/IEC TR-24733 of 2009 and its C++11
// updates of ISO/IEC JTC1 SC22 WG21 N3407=12-0097 of 2012 as much as it is
// possible with C++03 compilers and environments that do not provide decimal
// floating-point support in any form.
//
// At the time of writing there is just one standard about decimal-floating
// point, the IEEE-754 2008 standard and the content of this component conforms
// to it.  The component does not fully implement all required IEEE-754
// functionality because due to our architectural design guidelines some of
// these must go into a separate so-called utility component.)
//
// The component uses the ISO/IEC TR 24732 - the C Decimal Floating-Point
// TR - in its implementation where it is available.
//
// The component closely resembles ISO/IEC TR 24733 - the C++ Decimal
// Floating-Point TR - but does not fully conform to it for several reasons.
// The major reasons are: it is well known that TR 24733 has to change before
// it is included into the C++ standard; the TR would require us to change
// system header files we do not have access to.
//
// In the following subsections the differences to the C++ technical report are
// explained in detail, including a short rationale.
//
///No Namespace Level Named Functions
/// - - - - - - - - - - - - - - - - -
// BDE design guidelines do not allow namespace level functions other than
// operators and aspects.  According to BDE design principles all such
// functions are placed into a utility component.
//
///All Converting Constructors from Integer Types are Explicit
///- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// This change is necessary to disable the use of comparison operators without
// explicit casting.  See No Heterogeneous Comparisons Without Casting.
//
///No Heterogeneous Comparisons Without Casting
/// - - - - - - - - - - - - - - - - - - - - - -
// The C and C++ Decimal TRs refer to IEEE-754 for specifications of the
// heterogeneous comparison operators (comparing decimal floating-point types
// to binary floating-point types and integer types); however IEEE-754 does
// *not* specify such operations - leaving them unspecified.  To make matters
// worse, there are two possible ways to implement those operators (convert the
// decimal to the other type, or convert the other type to decimal first) and
// depending on which one is chosen, the result of the operator will be
// different.  Also, the C committee is considering the removal of those
// operators.  We have removed them until we know how to implement them.
// Comparing decimal types to those other types is still possible, it just
// requires explicit casting/conversion from the user code.
//
///Arithmetic And Computing Support For 'Decimal32'
/// - - - - - - - - - - - - - - - - - - - - - - - - -
// IEEE-754 designates the 32 bit floating-point types "interchange formats"
// and does not require or recommend arithmetic or computing support of any
// kind for them.  The C (and consequently the C++) TR goes against the IEEE
// design and requires '_Decimal32' (and 'std::decimal32') to provide computing
// support, however, in a twist, allows it to be performed using one of the
// larger types (64 or 128 bits).  The rationale from the C committee is that
// small embedded systems may need to do their calculations using the small
// type (so they have made it mandatory for everyone).  To conform the
// requirement we provide arithmetic and computing support for Decimal32 type
// but users need to be aware of the drawbacks of calculations using the small
// type. Industry experience with the 'float' C type (32bit floating-point
// type, usually binary) has shown that enabling computing using small
// floating-point types are a mistake that causes novice programmers to write
// calculations that are very slow and inaccurate.
//
// We recommend what IEEE recommends: convert your 32 bit types on receipt to a
// type with higher precision (usually 64 bit will suffice), so you
// calculations using that larger type, and convert it back to 32 bit type only
// if your output interchange format requires it.
//
///Non-Standard Member Functions
///- - - - - - - - - - - - - - -
// Due to BDE rules of design and some implementation needs we have extended
// the C++ TR mandated interface of the decimal floating-point types to include
// support for accessing the underlying data (type), to parse literals for the
// portable literal support.
//
// Note that using any of these public member functions will render your code
// non-portable to non-BDE (but standards conforming) implementations.
//
///'Decimal32' Type
///----------------
// A basic format type that supports input, output, relational operators
// construction from the TR mandates data types and arithmetic or operations.
// The type has the size of exactly 32 bits.  It supports 7 significant decimal
// digits and an exponent range of -95 to 96.  The smallest non-zero value that
// can be represented is 1e-101.
//
// Portable 'Decimal32' literals are created using the 'BDLDFP_DECIMAL_DF'
// macro.
//
///'Decimal64' Type
///----------------
// A basic format type that supports input, output, relational operators
// construction from the TR mandates data types and arithmetic or operations.
// The type has the size of exactly 64 bits.  It supports 16 significant
// decimal digits and an exponent range of -383 to 384.  The smallest non-zero
// value that can be represented is 1e-398.
//
// Portable 'Decimal64' literals are created using the 'BDLDFP_DECIMAL_DD'
// macro.
//
///'Decimal128' Type
///-----------------
// A basic format type that supports input, output, relational operators
// construction from the TR mandates data types and arithmetic or operations.
// The type has the size of exactly 128 bits.  It supports 34 significant
// decimal digits and an exponent range of -6143 to 6144.  The smallest
// non-zero value that can be represented is 1e-6176.
//
// Portable 'Decimal128' literals are created using the 'BDLDFP_DECIMAL_DL'
// macro.
//
///Decimal Number Formatting
///-------------------------
// Streaming decimal floating point numbers to an output stream supports
// formatting flags for width, capitalization and justification and flags used
// to output numbers in natural, scientific and fixed notations.  When
// scientific or fixed flags are set then the precision manipulator specifies
// how many digits of the decimal number are to be printed, otherwise all
// significant digits of the decimal number are output using native notation.
//
///User-defined literals
///---------------------
// The user-defined literal 'operator "" _d32', 'operator "" _d64', and
// 'operator "" _d128' are declared for the 'bdldfp::Decimal32',
// 'bdldfp::Decimal64', and 'bdldfp::Decimal128' types respectively .  These
// user-defined literal suffixes can be applied to both numeric and string
// literals, (i.e., 1.2_d128, "1.2"_d128 or "inf"_d128) to produce a decimal
// floating-point value of the indicated type by parsing the argument string
// or numeric value:
//..
//  using namespace bdldfp::DecimalLiterals;
//
//  bdldfp::Decimal32   d0  = "1.2"_d32;
//  bdldfp::Decimal32   d1  =  1.2_d32;
//  assert(d0 == d1);
//
//  bdldfp::Decimal64   d2  = "3.45678901234"_d64;
//  bdldfp::Decimal64   d3  =  3.45678901234_d64;
//  assert(d2 == d3);
//
//  bdldfp::Decimal128  inf = "inf"_d128;
//  bdldfp::Decimal128  nan = "nan"_d128;
//..
// The operators providing literals are available in the
// 'BloombergLP::bdldfp::literals::DecimalLiterals' namespace (where 'literals'
// and 'DecimalLiterals' are both inline namespaces). Because of inline
// namespaces, there are several viable options for a using declaration, but
// *we* *recommend* 'using namespace bdldfp::DecimalLiterals', which minimizes
// the scope of the using declaration.
//
// Note that the parsing follows the rules as specified for the 'strtod32',
// 'strtod64' and 'strtod128' functions in section 9.6 of the ISO/EIC TR 247128
// C Decimal Floating-Point Technical Report.
//
// Also note that these operators can be used only if the compiler supports
// C++11 standard.
//
///Usage
///-----
// In this section, we show the intended usage of this component.
//
///Example 1: Portable Initialization of Non-Integer, Constant Values
/// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// If your compiler does not support the C Decimal TR, it does not support
// decimal floating-point literals, only binary floating-point literals.  The
// problem with binary floating-point literals is the same as with binary
// floating-point numbers in general: they cannot represent the decimal numbers
// we care about.  To solve this problem there are 3 macros provided by this
// component that can be used to initialize decimal floating-point types with
// non-integer values, precisely.  These macros will evaluate to real, C
// language literals where those are supported and to a runtime-parsed solution
// otherwise.  The following code demonstrates the use of these macros as well
// as mixed-type arithmetics and comparisons:
//..
//  bdldfp::Decimal32  d32( BDLDFP_DECIMAL_DF(0.1));
//  bdldfp::Decimal64  d64( BDLDFP_DECIMAL_DD(0.2));
//  bdldfp::Decimal128 d128(BDLDFP_DECIMAL_DL(0.3));
//
//  assert(d32 + d64 == d128);
//  assert(bdldfp::Decimal64(d32)  * 10 == bdldfp::Decimal64(1));
//  assert(d64  * 10 == bdldfp::Decimal64(2));
//  assert(d128 * 10 == bdldfp::Decimal128(3));
//..
//
///Example 2: Precise Calculations with Decimal Values
///- - - - - - - - - - - - - - - - - - - - - - - - - -
// Suppose we need to add two (decimal) numbers and then tell if the result is
// a particular decimal number or not.  That can get difficult with binary
// floating-point, but easy with decimal:
//..
//  if (std::numeric_limits<double>::radix == 2) {
//    assert(.1 + .2 != .3);
//  }
//  assert(BDLDFP_DECIMAL_DD(0.1) + BDLDFP_DECIMAL_DD(0.2)
//      == BDLDFP_DECIMAL_DD(0.3));
//..

#include <bdlscm_version.h>

#include <bdldfp_decimalimputil.h>
#include <bdldfp_decimalstorage.h>

#include <bslh_hash.h>

#include <bslma_default.h>

#include <bslmf_istriviallycopyable.h>
#include <bslmf_nestedtraitdeclaration.h>

#include <bsls_assert.h>
#include <bsls_compilerfeatures.h>
#include <bsls_keyword.h>
#include <bsls_libraryfeatures.h>
#include <bsls_platform.h>

#include <bsl_cstddef.h>
#include <bsl_cstring.h>
#include <bsl_ios.h>
#include <bsl_iosfwd.h>
#include <bsl_iterator.h>
#include <bsl_limits.h>
#include <bsl_locale.h>


#ifndef BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
#include <bslalg_typetraits.h>

#endif // BDE_DONT_ALLOW_TRANSITIVE_INCLUDES


               // Portable decimal floating-point literal support

#define BDLDFP_DECIMAL_DF(lit)                                                \
    BloombergLP::bdldfp::Decimal32(BDLDFP_DECIMALIMPUTIL_DF(lit))

#define BDLDFP_DECIMAL_DD(lit)                                                \
    BloombergLP::bdldfp::Decimal64(BDLDFP_DECIMALIMPUTIL_DD(lit))

#define BDLDFP_DECIMAL_DL(lit)                                                \
    BloombergLP::bdldfp::Decimal128(BDLDFP_DECIMALIMPUTIL_DL(lit))

namespace BloombergLP {
namespace bdldfp {

                            // FORWARD DECLARATIONS

class Decimal_Type32;
class Decimal_Type64;
class Decimal_Type128;
    // These are the actual (decimal floating-point) types being implemented.
    // They use a different name to cause an error if the official types are
    // forward declared: The exact definition of the decimal types is left
    // unspecified so that that can potentially be aliases for built-in types.

typedef Decimal_Type32  Decimal32;
typedef Decimal_Type64  Decimal64;
typedef Decimal_Type128 Decimal128;
    // The decimal floating-point types are typedefs to the unspecified
    // implementation types.

                      // THE DECIMAL FLOATING-POINT TYPES

                            // ====================
                            // class Decimal_Type32
                            // ====================

class Decimal_Type32 {
    // This value-semantic class implements the IEEE-754 32 bit decimal
    // floating-point interchange format type.  This class is a standard layout
    // type that is 'const' thread-safe and exception-neutral.

  private:
    // DATA
    DecimalImpUtil::ValueType32 d_value; // The underlying IEEE representation

  public:
    // CLASS METHODS

                                  // Aspects

    static int maxSupportedBdexVersion();
    static int maxSupportedBdexVersion(int versionSelector);
        // Return the maximum valid BDEX format version, as indicated by the
        // specified 'versionSelector', to be passed to the 'bdexStreamOut'
        // method.  Note that it is highly recommended that 'versionSelector'
        // be formatted as "YYYYMMDD", a date representation.  Also note that
        // 'versionSelector' should be a *compile*-time-chosen value that
        // selects a format version supported by both externalizer and
        // unexternalizer.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.

    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(Decimal_Type32, bsl::is_trivially_copyable);


    // CREATORS
    Decimal_Type32();
        // Create a 'Decimal32_Type' object having the value positive zero and
        // the smallest exponent value.

    Decimal_Type32(DecimalImpUtil::ValueType32 value);              // IMPLICIT
        // Create a 'Decimal32_Type' object having the specified 'value'.

    explicit Decimal_Type32(Decimal_Type64  other);
    explicit Decimal_Type32(Decimal_Type128 other);
        // Create a 'Decimal32_Type' object having the value closest to the
        // value of the specified 'other' following the conversion rules as
        // defined by IEEE-754:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'other' is infinity (positive or negative), then
        //:   initialize this object to infinity with the same sign.
        //:
        //: o Otherwise if 'other' has a zero value, then initialize this
        //:   object to zero with the same sign.
        //:
        //: o Otherwise if 'other' has an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   infinity with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   zero with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has a value that has more significant digits
        //:   than 'std::numeric_limits<Decimal32>::max_digit' then initialize
        //:   this object to the value of 'other' rounded according to the
        //:   rounding direction.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.

    explicit Decimal_Type32(float       other);
    explicit Decimal_Type32(double      other);
        // Create a 'Decimal32_Type' object having the value closest to the
        // value of the specified 'other' value.  *Warning:* clients requiring
        // a conversion for an exact decimal value should use
        // 'bdldfp_decimalconvertutil' (see *WARNING*: Conversions from
        // 'float' and 'double'}.  This conversion follows the conversion
        // rules as defined by IEEE-754:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'other' is infinity (positive or negative), then
        //:   initialize this object to infinity value with the same sign.
        //:
        //: o Otherwise if 'other' has a zero value, then initialize this
        //:   object to zero with the same sign.
        //:
        //: o Otherwise if 'other' has an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   infinity with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   zero with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has a value that has more significant digits
        //:   than 'std::numeric_limits<Decimal32>::max_digit' then initialize
        //:   this object to the value of 'other' rounded according to the
        //:   rounding direction.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.

    explicit Decimal_Type32(int                other);
    explicit Decimal_Type32(unsigned int       other);
    explicit Decimal_Type32(long int           other);
    explicit Decimal_Type32(unsigned long int  other);
    explicit Decimal_Type32(long long          other);
    explicit Decimal_Type32(unsigned long long other);
        // Create a 'Decimal32_Type' object having the value closest to the
        // value of the specified 'other' following the conversion rules as
        // defined by IEEE-754:
        //
        //: o If 'value' is zero then initialize this object to a zero with an
        //:   unspecified sign and an unspecified exponent.
        //:
        //: o Otherwise if 'other' has a value that is not exactly
        //:   representable using 'std::numeric_limits<Decimal32>::max_digit'
        //:   decimal digits then initialize this object to the value of
        //:   'other' rounded according to the rounding direction.
        //:
        //: o Otherwise initialize this object to the value of 'other' with
        //:   exponent 0.

    //! Decimal32_Type(const Decimal32_Type& original) = default;
        // Create a 'Decimal32_Type' object that is a copy of the specified
        // 'original' as defined by the 'copy' operation of IEEE-754 2008:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that a copy of a decimal will not compare equal to the original;
        // however it will behave as the original.

    //! ~Decimal32_Type() = default;
        // Destroy this object.

    // MANIPULATORS
    //! Decimal32_Type& operator=(const Decimal32_Type& rhs) = default;
        // Make this object a copy of the specified 'rhs' as defined by the
        // 'copy' operation of IEEE-754 2008 and return a reference providing
        // modifiable access to this object.
        //
        //: o If 'other' is NaN, set this object to a NaN.
        //:
        //: o Otherwise set this object to the value of the 'other'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that, after an assignment, a decimal will not compare equal to the
        // original; however it will behave as the original.

    Decimal_Type32& operator++();
        // Add 1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to 1.0 (if the original value is small).

    Decimal_Type32& operator--();
        // Add -1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to -1.0 (if the original value is small).

    Decimal_Type32& operator+=(Decimal32  rhs);
    Decimal_Type32& operator+=(Decimal64  rhs);
    Decimal_Type32& operator+=(Decimal128 rhs);
        // Add the value of the specified 'rhs' object to the value of this as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinity value of
        //:   differing signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinite values of the
        //:   same sign, then do not change this object.
        //:
        //: o Otherwise if 'rhs' has a zero value (positive or negative), do
        //:   not change this object.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal32>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and
        //:   set this object to infinity with the same sign as that result.
        //:
        //: o Otherwise set this object to the sum of the number represented by
        //:   'rhs' and the number represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Also note that when 'rhs' is a 'Decimal64', this operation is
        // always performed with 64 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.
        //
        // Also note that when 'rhs' is a 'Decimal128', this operation is
        // always performed with 128 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.

    Decimal_Type32& operator+=(int                rhs);
    Decimal_Type32& operator+=(unsigned int       rhs);
    Decimal_Type32& operator+=(long               rhs);
    Decimal_Type32& operator+=(unsigned long      rhs);
    Decimal_Type32& operator+=(long long          rhs);
    Decimal_Type32& operator+=(unsigned long long rhs);
        // Add the specified 'rhs' to the value of this object as described by
        // IEEE-754, store the result in this object, and return a reference to
        // this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal32>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and
        //:   set this object to infinity with the same sign as that result.
        //:
        //: o Otherwise set this object to sum of adding 'rhs' and the number
        //:   represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Also note that this operation is always performed with 64 bits
        // precision to prevent loss of precision of the 'rhs' operand (prior
        // to the operation).  The result is then rounded back to 32 bits and
        // stored to this object.  See IEEE-754 2008, 5.1, first paragraph,
        // second sentence for specification.


    Decimal_Type32& operator-=(Decimal32  rhs);
    Decimal_Type32& operator-=(Decimal64  rhs);
    Decimal_Type32& operator-=(Decimal128 rhs);
        // Subtract the value of the specified 'rhs' from the value of this
        // object as described by IEEE-754, store the result in this object,
        // and return a reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinity value of the
        //:   same signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and the 'rhs' have infinite values of
        //:   differing signs, then do not change this object.
        //:
        //: o Otherwise if the 'rhs' has a zero value (positive or negative),
        //:   do not change this object.
        //:
        //: o Otherwise if subtracting the value of the 'rhs' object from this
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting the value
        //:   of 'rhs' from the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Also note that when 'rhs' is a 'Decimal64', this operation is
        // always performed with 64 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.
        //
        // Also note that when 'rhs' is a 'Decimal128', this operation is
        // always performed with 128 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.

    Decimal_Type32& operator-=(int                rhs);
    Decimal_Type32& operator-=(unsigned int       rhs);
    Decimal_Type32& operator-=(long               rhs);
    Decimal_Type32& operator-=(unsigned long      rhs);
    Decimal_Type32& operator-=(long long          rhs);
    Decimal_Type32& operator-=(unsigned long long rhs);
        // Subtract the specified 'rhs' from the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if subtracting 'rhs' from this object's value results
        //:   in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting 'rhs' from
        //:   the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Also note that this operation is always performed with 64 bits
        // precision to prevent loss of precision of the 'rhs' operand (prior
        // to the operation).  The result is then rounded back to 32 bits and
        // stored to this object.  See IEEE-754 2008, 5.1, first paragraph,
        // second sentence for specification.

    Decimal_Type32& operator*=(Decimal32  rhs);
    Decimal_Type32& operator*=(Decimal64  rhs);
    Decimal_Type32& operator*=(Decimal128 rhs);
        // Multiply the value of the specified 'rhs' object by the value of
        // this as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise, if one of this object and 'rhs' is zero (positive or
        //:   negative) and the other is infinity (positive or negative), store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise, if either this object or 'rhs' is positive or negative
        //:   infinity, set this object to infinity.  The sign of this object
        //:   will be positive if this object and 'rhs' had the same sign, and
        //:   negative otherwise.
        //:
        //: o Otherwise, if either this object or 'rhs' is zero, set this
        //:   object to zero.  The sign of this object will be positive if this
        //:   object and 'rhs' had the same sign, and negative otherwise.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal32>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and set
        //:   this object to infinity with the same sign of that result.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero value
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the product of the value of 'rhs'
        //:   and the value of this object.
        //
        // Note that when 'rhs' is a 'Decimal64', this operation is always
        // performed with 64 bits precision to prevent loss of precision of the
        // 'rhs' operand (prior to the operation).  The result is then rounded
        // back to 32 bits and stored to this object.  See IEEE-754 2008, 5.1,
        // first paragraph, second sentence for specification.
        //
        // Also note that when 'rhs' is a 'Decimal128', this operation is
        // always performed with 128 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.

    Decimal_Type32& operator*=(int                rhs);
    Decimal_Type32& operator*=(unsigned int       rhs);
    Decimal_Type32& operator*=(long               rhs);
    Decimal_Type32& operator*=(unsigned long      rhs);
    Decimal_Type32& operator*=(long long          rhs);
    Decimal_Type32& operator*=(unsigned long long rhs);
        // Multiply the specified 'rhs' by the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity (positive or negative), and
        //:   'rhs' is zero, then store the value of the macro 'EDOM' into
        //:   'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative), then
        //:   do not change it.
        //:
        //: o Otherwise if 'rhs' is zero, then set this object to zero with the
        //:   same sign as its value had prior to this operation.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero with
        //:   the same sign as that result.
        //:
        //: o Otherwise set this object to the product of the value of this
        //:   object and the value 'rhs'.
        //
        // Note that this operation is always performed with 64 bits precision
        // to prevent loss of precision of the 'rhs' operand (prior to the
        // operation).  The result is then rounded back to 32 bits and stored
        // to this object.  See IEEE-754 2008, 5.1, first paragraph,

    Decimal_Type32& operator/=(Decimal32  rhs);
    Decimal_Type32& operator/=(Decimal64  rhs);
    Decimal_Type32& operator/=(Decimal128 rhs);
        // Divide the value of this object by the value of the specified 'rhs'
        // as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' are both infinity (positive or
        //:   negative) or both zero (positive or negative) then store the
        //:   value of the macro 'EDOM' into 'errno' and return a NaN.
        //:
        //: o Otherwise if 'rhs' has a positive zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the same sign as its original value.
        //:
        //: o Otherwise if 'rhs' has a negative zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the opposite sign as its original value.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.
        //
        // Note that when 'rhs' is a 'Decimal64', this operation is always
        // performed with 64 bits precision to prevent loss of precision of the
        // 'rhs' operand (prior to the operation).  The result is then rounded
        // back to 32 bits and stored to this object.  See IEEE-754 2008, 5.1,
        // first paragraph, second sentence for specification.
        //
        // Also note that when 'rhs' is a 'Decimal128', this operation is
        // always performed with 128 bits precision to prevent loss of
        // precision of the 'rhs' operand (prior to the operation).  The
        // result is then rounded back to 32 bits and stored to this object.
        // See IEEE-754 2008, 5.1, first paragraph, second sentence for
        // specification.

    Decimal_Type32& operator/=(int                rhs);
    Decimal_Type32& operator/=(unsigned int       rhs);
    Decimal_Type32& operator/=(long               rhs);
    Decimal_Type32& operator/=(unsigned long      rhs);
    Decimal_Type32& operator/=(long long          rhs);
    Decimal_Type32& operator/=(unsigned long long rhs);
        // Divide the value of this object by the specified 'rhs' as described
        // by IEEE-754, store the result in this object, and return a reference
        // to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN then set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is positive value then set this object to infinity value
        //:   with the same sign as its original value.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is negative value then set this object to infinity value
        //:   with the opposite sign as its original value.
        //:
        //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
        //:   into 'errno' and set this object to infinity with the same sign
        //:   it had prior to this operation.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal32>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal32>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.
        //
        // Note that this operation is always performed with 64 bits precision
        // to prevent loss of precision of the 'rhs' operand (prior to the
        // operation).  The result is then rounded back to 32 bits and stored
        // to this object.  See IEEE-754 2008, 5.1, first paragraph,

    DecimalImpUtil::ValueType32 *data();
        // Return a pointer providing modifiable access to the underlying
        // implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamIn(STREAM& stream, int version);
        // Assign to this object the value read from the specified input
        // 'stream' using the specified 'version' format, and return a
        // reference to 'stream'.  If 'stream' is initially invalid, this
        // operation has no effect.  If 'version' is not supported, this object
        // is unaltered and 'stream' is invalidated, but otherwise unmodified.
        // If 'version' is supported but 'stream' becomes invalid during this
        // operation, this object has an undefined, but valid, state.  Note
        // that no version is read from 'stream'.  See the 'bslx' package-level
        // documentation for more information on BDEX streaming of
        // value-semantic types and containers.

    // ACCESSORS
    const DecimalImpUtil::ValueType32 *data() const;
        // Return a pointer providing non-modifiable access to the underlying
        // implementation.

    DecimalImpUtil::ValueType32 value() const;
        // Return the value of the underlying implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamOut(STREAM& stream, int version) const;
        // Write the value of this object, using the specified 'version'
        // format, to the specified output 'stream', and return a reference to
        // 'stream'.  If 'stream' is initially invalid, this operation has no
        // effect.  If 'version' is not supported, 'stream' is invalidated, but
        // otherwise unmodified.  Note that 'version' is not written to
        // 'stream'.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.
};

// FREE OPERATORS
Decimal32 operator+(Decimal32 value);
    // Return a copy of the specified 'value' if the value is not negative
    // zero, and return positive zero otherwise.

Decimal32 operator-(Decimal32 value);
    // Return the result of applying the unary - operator to the specified
    // 'value' as described by IEEE-754, essentially reversing the sign bit.
    // Note that floating-point numbers have signed zero, so this operation is
    // not the same as '0 - value'.

Decimal32 operator++(Decimal32& value, int);
    // Apply the prefix ++ operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operation may not change the value of this object at all (if the value
    // is large) or it may just set it to 1.0 (if the original value is small).

Decimal32 operator--(Decimal32& value, int);
    // Apply the prefix -- operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operation may not change the value of this object at all (if the value
    // is large) or it may just set it to -1.0 (if the original value is
    // small).

Decimal32 operator+(Decimal32 lhs, Decimal32 rhs);
    // Add the value of the specified 'rhs' to the value of the specified 'lhs'
    // as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of differing signs, store
    //:   the value of the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of the same sign then
    //:   return infinity of that sign.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal32>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and set this object to
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the sum of the number represented by 'lhs' and the
    //:   number represented by 'rhs'.

Decimal32 operator+(Decimal32 lhs, int                rhs);
Decimal32 operator+(Decimal32 lhs, unsigned int       rhs);
Decimal32 operator+(Decimal32 lhs, long               rhs);
Decimal32 operator+(Decimal32 lhs, unsigned long      rhs);
Decimal32 operator+(Decimal32 lhs, long long          rhs);
Decimal32 operator+(Decimal32 lhs, unsigned long long rhs);
    // Add the specified 'rhs' to the value of the specified 'lhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal32>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'rhs' and the number represented by
    //:   'lhs'.

Decimal32 operator+(int                lhs, Decimal32 rhs);
Decimal32 operator+(unsigned int       lhs, Decimal32 rhs);
Decimal32 operator+(long               lhs, Decimal32 rhs);
Decimal32 operator+(unsigned long      lhs, Decimal32 rhs);
Decimal32 operator+(long long          lhs, Decimal32 rhs);
Decimal32 operator+(unsigned long long lhs, Decimal32 rhs);
    // Add the specified 'lhs' to the value of the specified 'rhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal32>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'lhs' and the number represented by
    //:   'rhs'.

Decimal32 operator-(Decimal32 lhs, Decimal32 rhs);
    // Subtract the value of the specified 'rhs' from the value of the
    // specified 'lhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of the same
    //:   sign, store the value of the macro 'EDOM' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of differing
    //:   signs, then return 'lhs'.
    //:
    //: o Otherwise if the subtracting of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal32>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs' from
    //:   the value of 'lhs'.

Decimal32 operator-(Decimal32 lhs, int                rhs);
Decimal32 operator-(Decimal32 lhs, unsigned int       rhs);
Decimal32 operator-(Decimal32 lhs, long               rhs);
Decimal32 operator-(Decimal32 lhs, unsigned long      rhs);
Decimal32 operator-(Decimal32 lhs, long long          rhs);
Decimal32 operator-(Decimal32 lhs, unsigned long long rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting 'rhs' from the value of
    //:   'lhs'.

Decimal32 operator-(int                lhs, Decimal32 rhs);
Decimal32 operator-(unsigned int       lhs, Decimal32 rhs);
Decimal32 operator-(long               lhs, Decimal32 rhs);
Decimal32 operator-(unsigned long      lhs, Decimal32 rhs);
Decimal32 operator-(long long          lhs, Decimal32 rhs);
Decimal32 operator-(unsigned long long lhs, Decimal32 rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs' from
    //:   the number 'lhs'.

Decimal32 operator*(Decimal32 lhs, Decimal32 rhs);
    // Multiply the value of the specified 'lhs' object by the value of the
    // specified 'rhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if one of the operands is infinity (positive or negative)
    //:   and the other is zero (positive or negative), then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if both 'lhs' and 'rhs' are infinity (positive or
    //:   negative), return infinity.  The sign of the returned value will be
    //:   positive if 'lhs' and 'rhs' have the same sign, and negative
    //:   otherwise.
    //:
    //: o Otherwise, if either 'lhs' or 'rhs' is zero, return zero.  The sign
    //:   of the returned value will be positive if 'lhs' and 'rhs' have the
    //:   same sign, and negative otherwise.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal32>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is smaller than 'std::numeric_limits<Decimal32>::min()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return zero
    //:   with the same sign as that result.
    //:
    //: o Otherwise return the product of the value of 'rhs' and the number
    //:   represented by 'rhs'.

Decimal32 operator*(Decimal32 lhs, int                rhs);
Decimal32 operator*(Decimal32 lhs, unsigned int       rhs);
Decimal32 operator*(Decimal32 lhs, long               rhs);
Decimal32 operator*(Decimal32 lhs, unsigned long      rhs);
Decimal32 operator*(Decimal32 lhs, long long          rhs);
Decimal32 operator*(Decimal32 lhs, unsigned long long rhs);
    // Multiply the specified 'rhs' by the value of the specified 'lhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), and 'rhs' is
    //:   zero, then store the value of the macro 'EDOM' into 'errno' and
    //:   return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), then return
    //:   'lhs'.
    //:
    //: o Otherwise if 'rhs' is zero, then return zero with the sign of 'lhs'.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal32>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal32 operator*(int                lhs, Decimal32 rhs);
Decimal32 operator*(unsigned int       lhs, Decimal32 rhs);
Decimal32 operator*(long               lhs, Decimal32 rhs);
Decimal32 operator*(unsigned long      lhs, Decimal32 rhs);
Decimal32 operator*(long long          lhs, Decimal32 rhs);
Decimal32 operator*(unsigned long long lhs, Decimal32 rhs);
    // Multiply the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, then store the value of the macro 'EDOM' into 'errno' and
    //:   return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), then return
    //:   'rhs'.
    //:
    //: o Otherwise if 'lhs' is zero, then return zero with the sign of 'rhs'.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal32>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal32 operator/(Decimal32 lhs, Decimal32 rhs);
    // Divide the value of the specified 'lhs' by the value of the specified
    // 'rhs' as described by IEEE-754, and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are both infinity (positive or negative)
    //:   or both zero (positive or negative) then store the value of the macro
    //:   'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a positive zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a negative zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a positive zero
    //:   value, return infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a negative zero
    //:   value, return infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal32>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.

Decimal32 operator/(Decimal32 lhs, int                rhs);
Decimal32 operator/(Decimal32 lhs, unsigned int       rhs);
Decimal32 operator/(Decimal32 lhs, long               rhs);
Decimal32 operator/(Decimal32 lhs, unsigned long      rhs);
Decimal32 operator/(Decimal32 lhs, long long          rhs);
Decimal32 operator/(Decimal32 lhs, unsigned long long rhs);
    // Divide the value of the specified 'lhs' by the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   positive value then return infinity value with the same sign as its
    //:   original value.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   negative value then return infinity value with the opposite sign as
    //:   its original value.
    //:
    //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
    //:   into 'errno' and return infinity with the same sign it had prior to
    //:   this operation.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal32>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value 'rhs'.

Decimal32 operator/(int                lhs, Decimal32 rhs);
Decimal32 operator/(unsigned int       lhs, Decimal32 rhs);
Decimal32 operator/(long               lhs, Decimal32 rhs);
Decimal32 operator/(unsigned long      lhs, Decimal32 rhs);
Decimal32 operator/(long long          lhs, Decimal32 rhs);
Decimal32 operator/(unsigned long long lhs, Decimal32 rhs);
    // Divide the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, store the value of the macro 'ERANGE' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'rhs' is zero (positive or negative), store the value of
    //:   the macro 'ERANGE' into 'errno' and return infinity with the sign of
    //:   'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal32>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value 'rhs'.  Note that this is a floating-point operation, not
    //:   integer.

bool operator==(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' have the same value, and
    // 'false' otherwise.  Two 'Decimal32' objects have the same value if the
    // 'compareQuietEqual' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representations equal.  In
    // other words, two 'Decimal32' objects have the same value if:
    //
    //: o both have a zero value (positive or negative), or
    //: o both have the same infinity value (both positive or negative), or
    //: o both have the value of a real number that are equal, even if they are
    //:   represented differently (cohorts have the same value)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal32 aNaN = std::numeric_limits<Decimal32>::quiet_NaN();
    //  assert(!(aNan == aNan));
    //..

bool operator!=(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' do not have the same
    // value, and 'false' otherwise.  Two 'Decimal32' objects do not have the
    // same value if the 'compareQuietEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representations not equal.  In other words, two 'Decimal32' objects do
    // not have the same value if:
    //
    //: o both are NaN, or
    //: o one is zero (positive or negative) and the other is not, or
    //: o one is positive infinity and the other is not, or
    //: o one is negative infinity and the other is not, or
    //: o both have the value of a real number that are not equal, regardless
    //:   of their representation (cohorts are equal)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal32 aNaN = std::numeric_limits<Decimal32>::quiet_NaN();
    //  assert(aNan != aNan);
    //..

bool operator<(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value less than the specified
    // 'rhs' and 'false' otherwise.  The value of a 'Decimal32' object 'lhs' is
    // less than that of an object 'rhs' if the 'compareQuietLess' operation
    // (IEEE-754 defined, non-total ordering comparison) considers the
    // underlying IEEE representation of 'lhs' to be less than of that of
    // 'rhs'.  In other words, 'lhs' is less than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' positive, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' negative, or
    //: o 'lhs' is not positive infinity, or
    //: o 'lhs' is negative infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<=(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value less than or equal the
    // value of the specified 'rhs' and 'false' otherwise.  The value of a
    // 'Decimal32' object 'lhs' is less than or equal to the value of an object
    // 'rhs' if the 'compareQuietLessEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representation of 'lhs' to be less or equal to that of 'rhs'.  In other
    // words, 'lhs' is less or equal than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are positive infinity, or
    //: o 'lhs' is negative infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a greater value than the
    // specified 'rhs' and 'false' otherwise.  The value of a 'Decimal32'
    // object 'lhs' is greater than that of an object 'rhs' if the
    // 'compareQuietGreater' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representation of 'lhs' to be
    // greater than of that of 'rhs'.  In other words, 'lhs' is greater than
    // 'rhs'if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are not both zero (positive or negative), or
    //: o 'lhs' is not negative infinity, or
    //: o 'lhs' is positive infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>=(Decimal32 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value greater than or equal
    // to the value of the specified 'rhs' and 'false' otherwise.  The value of
    // a 'Decimal32' object 'lhs' is greater or equal to a 'Decimal32' object
    // 'rhs' if the 'compareQuietGreaterEqual' operation (IEEE-754 defined,
    // non-total ordering comparison ) considers the underlying IEEE
    // representation of 'lhs' to be greater or equal to that of 'rhs'.  In
    // other words, 'lhs' is greater than or equal to 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are negative infinity, or
    //: o 'lhs' is positive infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

template <class CHARTYPE, class TRAITS>
bsl::basic_istream<CHARTYPE, TRAITS>&
operator>>(bsl::basic_istream<CHARTYPE, TRAITS>& stream, Decimal32& object);
    // Read, into the specified 'object', from the specified input 'stream' an
    // IEEE 32 bit decimal floating-point value as described in the IEEE-754
    // 2008 standard (5.12 Details of conversions between floating point
    // numbers and external character sequences) and return a reference
    // providing modifiable access to 'stream'.  If 'stream' contains a NaN
    // value, it is unspecified if 'object' will receive a quiet or signaling
    // 'Nan'.  If 'stream' is not valid on entry 'stream.good() == false', this
    // operation has no effect other than setting 'stream.fail()' to 'true'.
    // If eof (end-of-file) is found before any non-whitespace characters
    // 'stream.fail()' is set to 'true' and 'object' remains unchanged.  If eof
    // is detected after some characters have been read (and successfully
    // interpreted as part of the textual representation of a floating-point
    // value as specified by IEEE-754) then 'stream.eof()' is set to true.  If
    // the first non-whitespace character sequence is not a valid textual
    // representation of a floating-point value (e.g., 12e or e12 or 1*2) the
    // 'stream.fail()' is set to true and 'object' will remain unchanged.  If a
    // real number value is represented by the character sequence but it is a
    // large positive or negative value that cannot be stored into 'object'
    // then store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative infinity is stored into 'object', respectively.  If a real
    // number value is represented by the character sequence but it is a small
    // positive or negative value that cannot be stored into 'object' then
    // store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative zero is stored into 'object', respectively.  If a real number
    // value is represented by the character sequence but it cannot be stored
    // exactly into 'object', the value is rounded according to the current
    // rounding direction (of the environment) and then stored into 'object'.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

template <class CHARTYPE, class TRAITS>
bsl::basic_ostream<CHARTYPE, TRAITS>&
operator<<(bsl::basic_ostream<CHARTYPE, TRAITS>& stream, Decimal32 object);
    // Write the value of the specified 'object' to the specified output
    // 'stream' in a single line format as described in the IEEE-754 2008
    // standard (5.12 Details of conversions between floating point numbers and
    // external character sequences), and return a reference providing
    // modifiable access to 'stream'.  If 'stream' is not valid on entry, this
    // operation has no effect.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline namespace literals {
inline namespace DecimalLiterals {
bdldfp::Decimal32  operator "" _d32 (const char *str);
bdldfp::Decimal32  operator "" _d32 (const char *str, bsl::size_t len);
    // Produce an object of the indicated return type by parsing the specified
    // 'str' having the specified 'len' excluding the terminating null
    // character that represents a floating-point number written in both fixed
    // and scientific notations.  These user-defined literal suffixes can be
    // applied to both numeric and string literals, (i.e., 1.2_d32, "1.2"_d32
    // or "inf"_d32). The resulting decimal object is initialized as follows:
    //
    //: o If 'str' does not represent a floating-point value, then return a
    //:   decimal object of the indicated return type initialized to a NaN.
    //:
    //: o Otherwise if 'str' represents infinity (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   infinity value with the same sign.
    //:
    //: o Otherwise if 'str' represents zero (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   zero with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is larger than the maximum value supported by the indicated return
    //:   type, then store the value of the macro 'ERANGE' into 'errno' and
    //:   return a decimal object of the return type initialized to infinity
    //:   with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is smaller than min value of the indicated return type, then store
    //:   the value of the macro 'ERANGE' into 'errno' and return a decimal
    //:   object of the return type initialized to zero with the same sign.
    //:
    //: o Otherwise if 'str' has a value that is not exactly representable
    //:   using the maximum digit number supported by the indicated return
    //:   type, then return a decimal object of the return type initialized to
    //:   the value represented by 'str' rounded according to the rounding
    //:   direction.
    //:
    //: o Otherwise return a decimal object of the indicated return type
    //:   initialized to the decimal value representation of 'str'.
    //
    // Note that the parsing follows the rules as specified for the 'strtod32'
    // function in section 9.6 of the ISO/EIC TR 247128 C Decimal
    // Floating-Point Technical Report.
    //
    // Also note that the numeric literal version omits the optional leading
    // sign in 'str'.  For example, if the string is -1.2_d32 then the string
    // "1.2" is passed to the one-argument form, not "-1.2", because leading
    // signs are operators, not parts of literals.  On the other hand, the
    // string literal version does not omit leading sign and if the string is
    // "-1.2"_d32 then the string "-1.2" is passed to the two-argument form.
    //
    // Also note that the quantum of the resultant value is affected by the
    // number of decimal places in 'str' string in both numeric and string
    // literal formats starting with the most significand digit and cannot
    // exceed the maximum number of digits necessary to differentiate all
    // values of the indicated return type, for example:
    //
    // '0.015_d32;     "0.015"_d32     =>      15e-3'
    // '1.5_d32;       "1.5"_d32       =>      15e-1'
    // '1.500_d32;     "1.500"d_32     =>    1500e-3'
    // '1.2345678_d32; "1.2345678_d32" => 1234568e-6'

}  // close DecimalLiterals namespace
}  // close literals namespace
#endif

// FREE FUNCTIONS
template <class HASHALG>
void hashAppend(HASHALG& hashAlg, const Decimal32& object);
    // Pass the specified 'object' to the specified 'hashAlg'.  This function
    // integrates with the 'bslh' modular hashing system and effectively
    // provides a 'bsl::hash' specialization for 'Decimal32'.  Note that two
    // objects which have the same value but different representations will
    // hash to the same value.

                            // ====================
                            // class Decimal_Type64
                            // ====================

class Decimal_Type64 {
    // This value-semantic class implements the IEEE-754 64 bit decimal
    // floating-point format arithmetic type.  This class is a standard layout
    // type that is 'const' thread-safe and exception-neutral.

  private:
    // DATA
    DecimalImpUtil::ValueType64 d_value; // The underlying IEEE representation

  public:
    // CLASS METHODS

                                  // Aspects

    static int maxSupportedBdexVersion();
    static int maxSupportedBdexVersion(int versionSelector);
        // Return the maximum valid BDEX format version, as indicated by the
        // specified 'versionSelector', to be passed to the 'bdexStreamOut'
        // method.  Note that it is highly recommended that 'versionSelector'
        // be formatted as "YYYYMMDD", a date representation.  Also note that
        // 'versionSelector' should be a *compile*-time-chosen value that
        // selects a format version supported by both externalizer and
        // unexternalizer.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.

    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(Decimal_Type64, bsl::is_trivially_copyable);


    // CREATORS
    Decimal_Type64();
        // Create a 'Decimal64_Type' object having the value positive zero and
        // the smallest exponent value.

    Decimal_Type64(DecimalImpUtil::ValueType64 value);              // IMPLICIT
        // Create a 'Decimal64_Type' object having the specified 'value'.

    Decimal_Type64(Decimal32 other);                                // IMPLICIT
        // Create a 'Decimal64_Type' object having the value of the specified
        // 'other' following the conversion rules as defined by IEEE-754:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'other' is infinity (positive or negative), then
        //:   initialize this object to infinity with the same sign.
        //:
        //: o Otherwise if 'other' is zero, then initialize this object to zero
        //:   with the same sign.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.

    explicit Decimal_Type64(Decimal128 other);
        // Create a 'Decimal64_Type' object having the value closest to the
        // value of the specified 'other' following the conversion rules as
        // defined by IEEE-754:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'other' is infinity (positive or negative), then
        //:   initialize this object to infinity with the same sign.
        //:
        //: o Otherwise if 'other' is zero, then initialize this object to
        //:   zero with the same sign.
        //:
        //: o Otherwise if 'other' has an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   infinity with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal64>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   zero with the same sign as 'other'.
        //:
        //: o Otherwise if 'other' has a value that has more significant
        //:   digits than 'std::numeric_limits<Decimal64>::max_digit' then
        //:   initialize this object to the value of 'other' rounded according
        //:   to the rounding direction.
        //:
        //: o Otherwise initialize this object to the value as the 'other'.

    explicit Decimal_Type64(float       other);
    explicit Decimal_Type64(double      other);
        // Create a 'Decimal64_Type' object having the value closest to the
        // value of the specified 'other' value.  *Warning:* clients requiring
        // a conversion for an exact decimal value should use
        // 'bdldfp_decimalconvertutil' (see *WARNING*: Conversions from
        // 'float' and 'double'}.  This conversion follows the conversion
        // rules as defined by IEEE-754:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'other' is infinity (positive or negative), then
        //:   initialize this object to infinity value with the same sign.
        //:
        //: o Otherwise if 'other' has a zero value, then initialize this
        //:   object to zero with the same sign.
        //:
        //: o Otherwise if 'other' has a value that needs more than
        //:   'std::numeric_limits<Decimal64>::max_digit' significant decimal
        //:   digits to represent then initialize this object to the value of
        //:   'other' rounded according to the rounding direction.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.

    explicit Decimal_Type64(int                other);
    explicit Decimal_Type64(unsigned int       other);
    explicit Decimal_Type64(long               other);
    explicit Decimal_Type64(unsigned long      other);
    explicit Decimal_Type64(long long          other);
    explicit Decimal_Type64(unsigned long long other);
        // Create a 'Decimal64_Type' object having the value closest to the
        // value of the specified 'other' following the conversion rules as
        // defined by IEEE-754:
        //
        //: o Otherwise if 'other' has a value that is not exactly
        //:   representable using 'std::numeric_limits<Decimal64>::max_digit'
        //:   decimal digits then initialize this object to the value of
        //:   'other' rounded according to the rounding direction.
        //:
        //: o Otherwise initialize this object to the value of 'other' with
        //:   exponent 0.

    //! Decimal64_Type(const Decimal64_Type& original) = default;
        // Create a 'Decimal64_Type' object that is a copy of the specified
        // 'original' as defined by the 'copy' operation of IEEE-754 2008:
        //
        //: o If 'other' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise initialize this object to the value of the 'other'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that a copy of a decimal will not compare equal to the original;
        // however it will behave as the original.

    //! ~Decimal64_Type() = default;
        // Destroy this object.

    // MANIPULATORS
    //! Decimal64_Type& operator=(const Decimal64_Type& rhs) = default;
        // Make this object a copy of the specified 'rhs' as defined by the
        // 'copy' operation of IEEE-754 2008 and return a reference providing
        // modifiable access to this object.
        //
        //: o If 'other' is NaN, set this object to a NaN.
        //:
        //: o Otherwise set this object to the value of the 'other'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that, after an assignment, a decimal will not compare equal to the
        // original; however it will behave as the original.

    Decimal_Type64& operator++();
        // Add 1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to 1.0 (if the original value is small).

    Decimal_Type64& operator--();
        // Add -1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to -1.0 (if the original value is small).

    Decimal_Type64& operator+=(Decimal32  rhs);
    Decimal_Type64& operator+=(Decimal64  rhs);
    Decimal_Type64& operator+=(Decimal128 rhs);
        // Add the value of the specified 'rhs' object to the value of this as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinite values of
        //:   differing signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinite values of the
        //:   same sign, then do not change this object.
        //:
        //: o Otherwise if 'rhs' has a zero value (positive or negative), do
        //:   not change this object.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal64>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and
        //:   set this object to infinity with the same sign as that result.
        //:
        //: o Otherwise set this object to the sum of the number represented by
        //:   'rhs' and the number represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Note that when 'rhs' is a 'Decimal128', this operation is always
        // performed with 128 bits precision to prevent loss of precision of
        // the 'rhs' operand (prior to the operation).  The result is then
        // rounded back to 64 bits and stored to this object.  See IEEE-754
        // 2008, 5.1, first paragraph, second sentence for specification.

    Decimal_Type64& operator+=(int                rhs);
    Decimal_Type64& operator+=(unsigned int       rhs);
    Decimal_Type64& operator+=(long               rhs);
    Decimal_Type64& operator+=(unsigned long      rhs);
    Decimal_Type64& operator+=(long long          rhs);
    Decimal_Type64& operator+=(unsigned long long rhs);
        // Add the specified 'rhs' to the value of this object as described by
        // IEEE-754, store the result in this object, and return a reference to
        // this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal64>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and
        //:   set this object to infinity with the same sign as that result.
        //:
        //: o Otherwise set this object to sum of adding 'rhs' and the number
        //:   represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type64& operator-=(Decimal32  rhs);
    Decimal_Type64& operator-=(Decimal64  rhs);
    Decimal_Type64& operator-=(Decimal128 rhs);
        // Subtract the value of the specified 'rhs' from the value of this
        // object as described by IEEE-754, store the result in this object,
        // and return a reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinity value of the
        //:   same signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and the 'rhs' have infinite values of
        //:   differing signs, then do not change this object.
        //:
        //: o Otherwise if the 'rhs' has a zero value (positive or negative),
        //:   do not change this object.
        //:
        //: o Otherwise if subtracting the value of the 'rhs' object from this
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting the value
        //:   of 'rhs' from the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).
        //
        // Note that when 'rhs' is a 'Decimal128', this operation is always
        // performed with 128 bits precision to prevent loss of precision of
        // the 'rhs' operand (prior to the operation).  The result is then
        // rounded back to 64 bits and stored to this object.  See IEEE-754
        // 2008, 5.1, first paragraph, second sentence for specification.

    Decimal_Type64& operator-=(int                rhs);
    Decimal_Type64& operator-=(unsigned int       rhs);
    Decimal_Type64& operator-=(long               rhs);
    Decimal_Type64& operator-=(unsigned long      rhs);
    Decimal_Type64& operator-=(long long          rhs);
    Decimal_Type64& operator-=(unsigned long long rhs);
        // Subtract the specified 'rhs' from the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if subtracting 'rhs' from this object's value results
        //:   in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting 'rhs' from
        //:   the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type64& operator*=(Decimal32  rhs);
    Decimal_Type64& operator*=(Decimal64  rhs);
    Decimal_Type64& operator*=(Decimal128 rhs);
        // Multiply the value of the specified 'rhs' object by the value of
        // this as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise, if one of this object and 'rhs' is zero (positive or
        //:   negative) and the other is infinity (positive or negative), store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise, if either this object or 'rhs' is positive or negative
        //:   infinity, set this object to infinity.  The sign of this object
        //:   will be positive if this object and 'rhs' had the same sign, and
        //:   negative otherwise.
        //:
        //: o Otherwise, if either this object or 'rhs' is zero, set this
        //:   object to zero.  The sign of this object will be positive if this
        //:   object and 'rhs' had the same sign, and negative otherwise.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is larger than 'std::numeric_limits<Decimal64>::max()'
        //:   then store the value of the macro 'ERANGE' into 'errno' and set
        //:   this object to infinity with the same sign of that result.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is smaller than
        //:   'std::numeric_limits<Decimal64>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero value
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the product of the value of 'rhs'
        //:   and the value of this object.
        //
        // Note that when 'rhs' is a 'Decimal128', this operation is always
        // performed with 128 bits precision to prevent loss of precision of
        // the 'rhs' operand (prior to the operation).  The result is then
        // rounded back to 64 bits and stored to this object.  See IEEE-754
        // 2008, 5.1, first paragraph, second sentence for specification.

    Decimal_Type64& operator*=(int                rhs);
    Decimal_Type64& operator*=(unsigned int       rhs);
    Decimal_Type64& operator*=(long               rhs);
    Decimal_Type64& operator*=(unsigned long      rhs);
    Decimal_Type64& operator*=(long long          rhs);
    Decimal_Type64& operator*=(unsigned long long rhs);
        // Multiply the specified 'rhs' by the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity (positive or negative), and
        //:   'rhs' is zero, then store the value of the macro 'EDOM' into
        //:   'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative), then
        //:   do not change it.
        //:
        //: o Otherwise if 'rhs' is zero, then set this object to zero with the
        //:   same sign as its value had prior to this operation.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal64>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero with
        //:   the same sign as that result.

    Decimal_Type64& operator/=(Decimal32  rhs);
    Decimal_Type64& operator/=(Decimal64  rhs);
    Decimal_Type64& operator/=(Decimal128 rhs);
        // Divide the value of this object by the value of the specified 'rhs'
        // as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' are both infinity (positive or
        //:   negative) or both zero (positive or negative), then store the
        //:   value of the macro 'EDOM' into 'errno' and return a NaN.
        //:
        //: o Otherwise if 'rhs' has a positive zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the same sign as its original value.
        //:
        //: o Otherwise if 'rhs' has a negative zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the opposite sign as its original value.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal64>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.
        //
        // Note that when 'rhs' is a 'Decimal128', this operation is always
        // performed with 128 bits precision to prevent loss of precision of
        // the 'rhs' operand (prior to the operation).  The result is then
        // rounded back to 64 bits and stored to this object.  See IEEE-754
        // 2008, 5.1, first paragraph, second sentence for specification.

    Decimal_Type64& operator/=(int                rhs);
    Decimal_Type64& operator/=(unsigned int       rhs);
    Decimal_Type64& operator/=(long               rhs);
    Decimal_Type64& operator/=(unsigned long      rhs);
    Decimal_Type64& operator/=(long long          rhs);
    Decimal_Type64& operator/=(unsigned long long rhs);
        // Divide the value of this object by the specified 'rhs' as described
        // by IEEE-754, store the result in this object, and return a reference
        // to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN then set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is positive value then set this object to infinity value
        //:   with the same sign as its original value.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is negative value then set this object to infinity value
        //:   with the opposite sign as its original value.
        //:
        //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
        //:   into 'errno' and set this object to infinity with the same sign
        //:   it had prior to this operation.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal64>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal64>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.

    DecimalImpUtil::ValueType64 *data();
        // Return a modifiable pointer to the underlying implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamIn(STREAM& stream, int version);
        // Assign to this object the value read from the specified input
        // 'stream' using the specified 'version' format, and return a
        // reference to 'stream'.  If 'stream' is initially invalid, this
        // operation has no effect.  If 'version' is not supported, this object
        // is unaltered and 'stream' is invalidated, but otherwise unmodified.
        // If 'version' is supported but 'stream' becomes invalid during this
        // operation, this object has an undefined, but valid, state.  Note
        // that no version is read from 'stream'.  See the 'bslx' package-level
        // documentation for more information on BDEX streaming of
        // value-semantic types and containers.

    // ACCESSORS
    const DecimalImpUtil::ValueType64 *data() const;
        // Return a non-modifiable pointer to the underlying implementation.

    DecimalImpUtil::ValueType64 value() const;
        // Return the value of the underlying implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamOut(STREAM& stream, int version) const;
        // Write the value of this object, using the specified 'version'
        // format, to the specified output 'stream', and return a reference to
        // 'stream'.  If 'stream' is initially invalid, this operation has no
        // effect.  If 'version' is not supported, 'stream' is invalidated, but
        // otherwise unmodified.  Note that 'version' is not written to
        // 'stream'.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.

    bsl::ostream& print(bsl::ostream& stream,
                        int           level = 0,
                        int           spacesPerLevel = 4) const;
        // Write the value of this object to the specified output 'stream' in a
        // human-readable format, and return a reference to 'stream'.
        // Optionally specify an initial indentation 'level', whose absolute
        // value is incremented recursively for nested objects.  If 'level' is
        // specified, optionally specify 'spacesPerLevel', whose absolute value
        // indicates the number of spaces per indentation level for this and
        // all of its nested objects.  If 'level' is negative, suppress
        // indentation of the first line.  If 'spacesPerLevel' is negative,
        // format the entire output on one line, suppressing all but the
        // initial indentation (as governed by 'level').  If 'stream' is not
        // valid on entry, this operation has no effect.  Note that this
        // human-readable format is not fully specified, and can change without
        // notice.
};

// FREE OPERATORS
Decimal64 operator+(Decimal64 value);
    // Return a copy of the specified 'value'.

Decimal64 operator-(Decimal64 value);
    // Return the result of applying the unary - operator to the specified
    // 'value' as described by IEEE-754.  Note that floating-point numbers have
    // signed zero, therefore this operation is not the same as '0-value'.

Decimal64 operator++(Decimal64& value, int);
    // Apply the prefix ++ operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operations may not change the value of this object at all (if the value
    // is large) or it may just set it to 1.0 (if the original value is small).

Decimal64 operator--(Decimal64& value, int);
    // Apply the prefix -- operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operations may not change the value of this object at all (if the value
    // is large) or it may just set it to -1.0 (if the original value is
    // small).

Decimal64 operator+(Decimal64 lhs, Decimal64 rhs);
Decimal64 operator+(Decimal32 lhs, Decimal64 rhs);
Decimal64 operator+(Decimal64 lhs, Decimal32 rhs);
    // Add the value of the specified 'rhs' to the value of the specified 'lhs'
    // as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of differing signs, store
    //:   the value of the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of the same sign then
    //:   return infinity of that sign.
    //:
    //: o Otherwise if 'rhs' is zero (positive or negative), return 'lhs'.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal64>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and set this object to
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the sum of the number represented by 'lhs' and the
    //:   number represented by 'rhs'.

Decimal64 operator+(Decimal64 lhs, int                rhs);
Decimal64 operator+(Decimal64 lhs, unsigned int       rhs);
Decimal64 operator+(Decimal64 lhs, long               rhs);
Decimal64 operator+(Decimal64 lhs, unsigned long      rhs);
Decimal64 operator+(Decimal64 lhs, long long          rhs);
Decimal64 operator+(Decimal64 lhs, unsigned long long rhs);
    // Add the specified 'rhs' to the value of the specified 'lhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal64>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'rhs' and the number represented by
    //:   'lhs'.

Decimal64 operator+(int                lhs, Decimal64 rhs);
Decimal64 operator+(unsigned int       lhs, Decimal64 rhs);
Decimal64 operator+(long               lhs, Decimal64 rhs);
Decimal64 operator+(unsigned long      lhs, Decimal64 rhs);
Decimal64 operator+(long long          lhs, Decimal64 rhs);
Decimal64 operator+(unsigned long long lhs, Decimal64 rhs);
    // Add the specified 'lhs' to the value of the specified 'rhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal64>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'lhs' and the number represented by
    //:   'rhs'.

Decimal64 operator-(Decimal64 lhs, Decimal64 rhs);
Decimal64 operator-(Decimal32 lhs, Decimal64 rhs);
Decimal64 operator-(Decimal64 lhs, Decimal32 rhs);
    // Subtract the value of the specified 'rhs' from the value of the
    // specified 'lhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of the same
    //:   sign, store the value of the macro 'EDOM' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of differing
    //:   signs, then return 'lhs'.
    //:
    //: o Otherwise if the subtracting of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal64>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs'from the
    //:   value of 'lhs'.

Decimal64 operator-(Decimal64 lhs, int                rhs);
Decimal64 operator-(Decimal64 lhs, unsigned int       rhs);
Decimal64 operator-(Decimal64 lhs, long               rhs);
Decimal64 operator-(Decimal64 lhs, unsigned long      rhs);
Decimal64 operator-(Decimal64 lhs, long long          rhs);
Decimal64 operator-(Decimal64 lhs, unsigned long long rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal32>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting 'rhs' from the value of
    //:   'lhs'.

Decimal64 operator-(int                lhs, Decimal64 rhs);
Decimal64 operator-(unsigned int       lhs, Decimal64 rhs);
Decimal64 operator-(long               lhs, Decimal64 rhs);
Decimal64 operator-(unsigned long      lhs, Decimal64 rhs);
Decimal64 operator-(long long          lhs, Decimal64 rhs);
Decimal64 operator-(unsigned long long lhs, Decimal64 rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs' from
    //:   the number 'lhs'.

Decimal64 operator*(Decimal64 lhs, Decimal64 rhs);
Decimal64 operator*(Decimal32 lhs, Decimal64 rhs);
Decimal64 operator*(Decimal64 lhs, Decimal32 rhs);
    // Multiply the value of the specified 'lhs' object by the value of the
    // specified 'rhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if one of the operands is infinity (positive or negative)
    //:   and the other is zero (positive or negative), then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if both 'lhs' and 'rhs' are infinity (positive or
    //:   negative), return infinity.  The sign of the returned value will be
    //:   positive if 'lhs' and 'rhs' have the same sign, and negative
    //:   otherwise.
    //:
    //: o Otherwise, if either 'lhs' or 'rhs' is zero, return zero.  The sign
    //:   of the returned value will be positive if 'lhs' and 'rhs' have the
    //:   same sign, and negative otherwise.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal64>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return an
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is smaller than 'std::numeric_limits<Decimal64>::min()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return zero
    //:   with the same sign as that result.
    //:
    //: o Otherwise return the product of the value of 'rhs' and the number
    //:   represented by 'rhs'.

Decimal64 operator*(Decimal64 lhs, int                rhs);
Decimal64 operator*(Decimal64 lhs, unsigned int       rhs);
Decimal64 operator*(Decimal64 lhs, long               rhs);
Decimal64 operator*(Decimal64 lhs, unsigned long      rhs);
Decimal64 operator*(Decimal64 lhs, long long          rhs);
Decimal64 operator*(Decimal64 lhs, unsigned long long rhs);
    // Multiply the specified 'rhs' by the value of the specified 'lhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), and 'rhs' is
    //:   zero, then store the value of the macro 'EDOM' into'errno' and return
    //:   a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), then return
    //:   'lhs'.
    //:
    //: o Otherwise if 'rhs' is zero, then return zero with the sign of 'lhs'.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal64>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal64 operator*(int                lhs, Decimal64 rhs);
Decimal64 operator*(unsigned int       lhs, Decimal64 rhs);
Decimal64 operator*(long               lhs, Decimal64 rhs);
Decimal64 operator*(unsigned long      lhs, Decimal64 rhs);
Decimal64 operator*(long long          lhs, Decimal64 rhs);
Decimal64 operator*(unsigned long long lhs, Decimal64 rhs);
    // Multiply the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, then store the value of the macro 'EDOM' into'errno' and return
    //:   a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), then return
    //:   'rhs'.
    //:
    //: o Otherwise if 'lhs' is zero, then return zero with the sign of 'rhs'.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal64>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal64 operator/(Decimal64 lhs, Decimal64 rhs);
Decimal64 operator/(Decimal32 lhs, Decimal64 rhs);
Decimal64 operator/(Decimal64 lhs, Decimal32 rhs);
    // Divide the value of the specified 'lhs' by the value of the specified
    // 'rhs' as described by IEEE-754, and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are both infinity (positive or negative)
    //:   or both zero (positive or negative) then store the value of the macro
    //:   'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a positive zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a negative zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a positive zero
    //:   value, return infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a negative zero
    //:   value, return infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal64>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.

Decimal64 operator/(Decimal64 lhs, int                rhs);
Decimal64 operator/(Decimal64 lhs, unsigned int       rhs);
Decimal64 operator/(Decimal64 lhs, long               rhs);
Decimal64 operator/(Decimal64 lhs, unsigned long      rhs);
Decimal64 operator/(Decimal64 lhs, long long          rhs);
Decimal64 operator/(Decimal64 lhs, unsigned long long rhs);
    // Divide the value of the specified 'lhs' by the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   positive value then return infinity value with the same sign as its
    //:   original value.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   negative value then return infinity value with the opposite sign as
    //:   its original value.
    //:
    //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
    //:   into 'errno' and return infinity with the same sign it had prior to
    //:   this operation.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal64>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value 'rhs'.

Decimal64 operator/(int                lhs, Decimal64 rhs);
Decimal64 operator/(unsigned int       lhs, Decimal64 rhs);
Decimal64 operator/(long               lhs, Decimal64 rhs);
Decimal64 operator/(unsigned long      lhs, Decimal64 rhs);
Decimal64 operator/(long long          lhs, Decimal64 rhs);
Decimal64 operator/(unsigned long long lhs, Decimal64 rhs);
    // Divide the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, store the value of the macro 'ERANGE' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'rhs' is zero (positive or negative), store the value of
    //:   the macro 'ERANGE' into 'errno' and return infinity with the sign of
    //:   'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal64>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal64>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.  Note that this is a floating-point operation, not
    //:   integer.

bool operator==(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' have the same value, and
    // 'false' otherwise.  Two 'Decimal64' objects have the same value if the
    // 'compareQuietEqual' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representations equal.  In
    // other words, two 'Decimal64' objects have the same value if:
    //
    //: o both have a zero value (positive or negative), or
    //: o both have the same infinity value (both positive or negative), or
    //: o both have the value of a real number that are equal, even if they are
    //:   represented differently (cohorts have the same value)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal64 aNaN = std::numeric_limits<Decimal64>::quiet_NaN();
    //  assert(!(aNan == aNan));
    //..

bool operator==(Decimal32 lhs, Decimal64 rhs);
bool operator==(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' have the same value, and
    // 'false' otherwise.  Two decimal objects have the same value if the
    // 'compareQuietEqual' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representations equal.  In
    // other words, two decimal objects have the same value if:
    //
    //: o both have a zero value (positive or negative), or
    //: o both have the same infinity value (both positive or negative), or
    //: o both have the value of a real number that are equal, even if they are
    //:   represented differently (cohorts have the same value)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator!=(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' do not have the same
    // value, and 'false' otherwise.  Two 'Decimal64' objects do not have the
    // same value if the 'compareQuietEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representations not equal.  In other words, two 'Decimal64' objects do
    // not have the same value if:
    //
    //: o both are a NaN, or
    //: o one has zero value (positive or negative) and the other does not, or
    //: o one has the value of positive infinity and the other does not, or
    //: o one has the value of negative infinity and the other does not, or
    //: o both have the value of a real number that are not equal, regardless
    //:   of their representation (cohorts are equal)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal64 aNaN = std::numeric_limits<Decimal64>::quiet_NaN();
    //  assert(aNan != aNan);
    //..

bool operator!=(Decimal32 lhs, Decimal64 rhs);
bool operator!=(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' do not have the same
    // value, and 'false' otherwise.  Two decimal objects do not have the same
    // value if the 'compareQuietEqual' operation (IEEE-754 defined, non-total
    // ordering comparison) considers the underlying IEEE representations not
    // equal.  In other words, two decimal objects do not have the same value
    // if:
    //
    //: o both are NaN, or
    //: o one has zero value (positive or negative) and the other does not, or
    //: o one has the value of positive infinity and the other does not, or
    //: o one has the value of negative infinity and the other does not, or
    //: o both have the value of a real number that are not equal, regardless
    //:   of their representation (cohorts are equal)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' has a value less than the specified
    // 'rhs' and 'false' otherwise.  The value of a 'Decimal64' object 'lhs' is
    // less than that of an object 'rhs' if the 'compareQuietLess' operation
    // (IEEE-754 defined, non-total ordering comparison) considers the
    // underlying IEEE representation of 'lhs' to be less than of that of
    // 'rhs'.  In other words, 'lhs' is less than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' is positive, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' negative, or
    //: o 'lhs' is not positive infinity, or
    //: o 'lhs' is negative infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<(Decimal32 lhs, Decimal64 rhs);
bool operator<(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value less than the specified
    // 'rhs' and 'false' otherwise.  The value of a decimal object 'lhs' is
    // less than that of an object 'rhs' if the 'compareQuietLess' operation
    // (IEEE-754 defined, non-total ordering comparison) considers the
    // underlying IEEE representation of 'lhs' to be less than of that of
    // 'rhs'.  In other words, 'lhs' is less than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' is positive, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' negative, or
    //: o 'lhs' is not positive infinity, or
    //: o 'lhs' is negative infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<=(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' has a value less than or equal the
    // value of the specified 'rhs' and 'false' otherwise.  The value of a
    // 'Decimal64' object 'lhs' is less than or equal to the value of an object
    // 'rhs' if the 'compareQuietLessEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representation of 'lhs' to be less or equal to that of 'rhs'.  In other
    // words, 'lhs' is less or equal than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are positive infinity, or
    //: o 'lhs' is negative infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<=(Decimal32 lhs, Decimal64 rhs);
bool operator<=(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value less than or equal the
    // value of the specified 'rhs' and 'false' otherwise.  The value of a
    // decimal object 'lhs' is less than or equal to the value of an object
    // 'rhs' if the 'compareQuietLessEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representation of 'lhs' to be less or equal to that of 'rhs'.  In other
    // words, 'lhs' is less or equal than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are positive infinity, or
    //: o 'lhs' is negative infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' has a greater value than the
    // specified 'rhs' and 'false' otherwise.  The value of a 'Decimal64'
    // object 'lhs' is greater than that of an object 'rhs' if the
    // 'compareQuietGreater' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representation of 'lhs' to be
    // greater than of that of 'rhs'.  In other words, 'lhs' is greater than
    // 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' positive, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' negative, or
    //: o 'lhs' is not negative infinity, or
    //: o 'lhs' is positive infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>(Decimal32 lhs, Decimal64 rhs);
bool operator>(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a greater value than the
    // specified 'rhs' and 'false' otherwise.  The value of a decimal object
    // 'lhs' is greater than that of an object 'rhs' if the
    // 'compareQuietGreater' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representation of 'lhs' to be
    // greater than of that of 'rhs'.  In other words, 'lhs' is greater than
    // 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' positive, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' negative, or
    //: o 'lhs' is not negative infinity, or
    //: o 'lhs' is positive infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>=(Decimal64 lhs, Decimal64 rhs);
    // Return 'true' if the specified 'lhs' has a value greater than or equal
    // to the value of the specified 'rhs' and 'false' otherwise.  The value of
    // a 'Decimal64' object 'lhs' is greater or equal to a 'Decimal64' object
    // 'rhs' if the 'compareQuietGreaterEqual' operation (IEEE-754 defined,
    // non-total ordering comparison ) considers the underlying IEEE
    // representation of 'lhs' to be greater or equal to that of 'rhs'.  In
    // other words, 'lhs' is greater than or equal to 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are negative infinity, or
    //: o 'lhs' is positive infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>=(Decimal32 lhs, Decimal64 rhs);
bool operator>=(Decimal64 lhs, Decimal32 rhs);
    // Return 'true' if the specified 'lhs' has a value greater than or equal
    // to the value of the specified 'rhs' and 'false' otherwise.  The value of
    // a decimal object 'lhs' is greater or equal to a decimal object 'rhs' if
    // the 'compareQuietGreaterEqual' operation (IEEE-754 defined, non-total
    // ordering comparison ) considers the underlying IEEE representation of
    // 'lhs' to be greater or equal to that of 'rhs'.  In other words, 'lhs' is
    // greater than or equal to 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are negative infinity, or
    //: o 'lhs' is positive infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

template <class CHARTYPE, class TRAITS>
bsl::basic_istream<CHARTYPE, TRAITS>&
operator>> (bsl::basic_istream<CHARTYPE, TRAITS>& stream, Decimal64& object);
    // Read, into the specified 'object', from the specified input 'stream' an
    // IEEE 64 bit decimal floating-point value as described in the IEEE-754
    // 2008 standard (5.12 Details of conversions between floating point
    // numbers and external character sequences) and return a reference
    // providing modifiable access to 'stream'.  If 'stream' contains a Nan
    // value, it is unspecified if 'object' will receive a quiet or signaling
    // 'Nan'.  If 'stream' is not valid on entry 'stream.good() == false', this
    // operation has no effect other than setting 'stream.fail()' to 'true'.
    // If eof (end-of-file) is found before any non-whitespace characters
    // 'stream.fail()' is set to 'true' and 'object' remains unchanged.  If eof
    // is detected after some characters have been read (and successfully
    // interpreted as part of the textual representation of a floating-point
    // value as specified by IEEE-754) then 'stream.eof()' is set to true.  If
    // the first non-whitespace character sequence is not a valid textual
    // representation of a floating-point value (e.g., 12e or e12 or 1*2) the
    // 'stream.fail()' is set to true and 'object' will remain unchanged.  If a
    // real number value is represented by the character sequence but it is a
    // large positive or negative value that cannot be stored into 'object'
    // then store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative infinity is stored into 'object', respectively.  If a real
    // number value is represented by the character sequence but it is a small
    // positive or negative value that cannot be stored into 'object' then
    // store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative zero is stored into 'object', respectively.  If a real number
    // value is represented by the character sequence but it cannot be stored
    // exactly into 'object', the value is rounded according to the current
    // rounding direction (of the environment) and then stored into 'object'.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

template <class CHARTYPE, class TRAITS>
bsl::basic_ostream<CHARTYPE, TRAITS>&
operator<< (bsl::basic_ostream<CHARTYPE, TRAITS>& stream, Decimal64 object);
    // Write the value of the specified 'object' to the specified output
    // 'stream' in a single line format as described in the IEEE-754 2008
    // standard (5.12 Details of conversions between floating point numbers and
    // external character sequences), and return a reference providing
    // modifiable access to 'stream'.  If 'stream' is not valid on entry, this
    // operation has no effect.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline namespace literals {
inline namespace DecimalLiterals {
bdldfp::Decimal64  operator "" _d64 (const char *str);
bdldfp::Decimal64  operator "" _d64 (const char *str, bsl::size_t len);
    // Produce an object of the indicated return type by parsing the specified
    // 'str' having the specified 'len' excluding the terminating null
    // character that represents a floating-point number written in both fixed
    // and scientific notations.  These user-defined literal suffixes can be
    // applied to both numeric and string literals, (i.e., 1.2_d128, "1.2"_d64
    // or "inf"_d64). The resulting decimal object is initialized as follows:
    //
    //: o If 'str' does not represent a floating-point value, then return a
    //:   decimal object of the indicated return type initialized to a NaN.
    //:
    //: o Otherwise if 'str' represents infinity (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   infinity value with the same sign.
    //:
    //: o Otherwise if 'str' represents zero (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   zero with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is larger than the maximum value supported by the indicated return
    //:   type, then store the value of the macro 'ERANGE' into 'errno' and
    //:   return a decimal object of the return type initialized to infinity
    //:   with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is smaller than min value of the indicated return type, then store
    //:   the value of the macro 'ERANGE' into 'errno' and return a decimal
    //:   object of the return type initialized to zero with the same sign.
    //:
    //: o Otherwise if 'str' has a value that is not exactly representable
    //:   using the maximum digit number supported by the indicated return
    //:   type, then return a decimal object of the return type initialized to
    //:   the value represented by 'str' rounded according to the rounding
    //:   direction.
    //:
    //: o Otherwise return a decimal object of the indicated return type
    //:   initialized to the decimal value representation of 'str'.
    //
    // Note that the parsing follows the rules as specified for the 'strtod64'
    // function in section 9.6 of the ISO/EIC TR 247128 C Decimal
    // Floating-Point Technical Report.
    //
    // Also note that the numeric literal version omits the optional leading
    // sign in 'str'.  For example, if the string is -1.2_d64 then the string
    // "1.2" is passed to the one-argument form, not "-1.2", because leading
    // signs are operators, not parts of literals.  On the other hand, the
    // string literal version does not omit leading sign and if the string is
    // "-1.2"_d64 then the string "-1.2" is passed to the two-argument form.
    //
    // Also note that the quantum of the resultant value is affected by the
    // number of decimal places in 'str' string in both numeric and string
    // literal formats starting with the most significand digit and cannot
    // exceed the maximum number of digits necessary to differentiate all
    // values of the indicated return type, for example:
    //
    // '0.015_d64;               =>              15e-3'
    // '1.5_d64;                 =>              15e-1'
    // '1.500_d64;               =>            1500e-3'
    // '1.2345678901234567_d64;  => 1234567890123458-15'

}  // close DecimalLiterals namespace
}  // close literals namespace
#endif

// FREE FUNCTIONS
template <class HASHALG>
void hashAppend(HASHALG& hashAlg, const Decimal64& object);
    // Pass the specified 'object' to the specified 'hashAlg'.  This function
    // integrates with the 'bslh' modular hashing system and effectively
    // provides a 'bsl::hash' specialization for 'Decimal64'.  Note that two
    // objects which have the same value but different representations will
    // hash to the same value.


                           // =====================
                           // class Decimal_Type128
                           // =====================

class Decimal_Type128 {
    // This value-semantic class implements the IEEE-754 128 bit decimal
    // floating-point format arithmetic type.  This class is a standard layout
    // type that is 'const' thread-safe and exception-neutral.

  private:
    // DATA
    DecimalImpUtil::ValueType128 d_value;
                                          // The underlying IEEE representation

  public:
    // CLASS METHODS

                                  // Aspects

    static int maxSupportedBdexVersion();
    static int maxSupportedBdexVersion(int versionSelector);
        // Return the maximum valid BDEX format version, as indicated by the
        // specified 'versionSelector', to be passed to the 'bdexStreamOut'
        // method.  Note that it is highly recommended that 'versionSelector'
        // be formatted as "YYYYMMDD", a date representation.  Also note that
        // 'versionSelector' should be a *compile*-time-chosen value that
        // selects a format version supported by both externalizer and
        // unexternalizer.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.

    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(Decimal_Type128,
                                   bsl::is_trivially_copyable);

    // CREATORS
    Decimal_Type128();
        // Create a 'Decimal128_Type' object having the value positive zero and
        // the smallest exponent value.

    Decimal_Type128(DecimalImpUtil::ValueType128 value);            // IMPLICIT
        // Create a 'Decimal128_Type' object having the specified 'value'.

    Decimal_Type128(Decimal32 value);                               // IMPLICIT
    Decimal_Type128(Decimal64 value);                               // IMPLICIT
        // Create a 'Decimal128_Type' object having the specified 'value',
        // subject to the conversion rules as defined by IEEE-754:
        //
        //: o If 'value' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'value' is infinity, then initialize this object to
        //:   infinity with the same sign.
        //:
        //: o Otherwise if 'value' is zero, then initialize this object to zero
        //:   with the same sign.
        //:
        //: o Otherwise initialize this object to 'value'.

    explicit Decimal_Type128(float  other);
    explicit Decimal_Type128(double other);
        // Create a 'Decimal128_Type' object having the value closest to the
        // specified 'other' value.  *Warning:* clients requiring a conversion
        // for an exact decimal value should use 'bdldfp_decimalconvertutil'
        // (see *WARNING*: Conversions from 'float' and 'double'}.  This
        // conversion follows the conversion rules as defined by IEEE-754:
        //
        //: o If 'value' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise if 'value' is infinity, then initialize this object to
        //:   infinity value with the same sign.
        //:
        //: o Otherwise if 'value' has a zero value, then initialize this
        //:   object to zero with the same sign.
        //:
        //: o Otherwise initialize this object to 'value'.

    explicit Decimal_Type128(int                value);
    explicit Decimal_Type128(unsigned int       value);
    explicit Decimal_Type128(long               value);
    explicit Decimal_Type128(unsigned long      value);
    explicit Decimal_Type128(long long          value);
    explicit Decimal_Type128(unsigned long long value);
        // Create a 'Decimal128_Type' object having the value closest to the
        // specified 'value' subject to the conversion rules as defined by
        // IEEE-754:
        //
        //: o If 'value' has an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and initialize this object to
        //:   infinity with the same sign as 'other'.
        //:
        //: o Otherwise if 'value' has a value that is not exactly
        //:   representable using 'std::numeric_limits<Decimal128>::max_digit'
        //:   decimal digits then initialize this object to the value of
        //:   'value' rounded according to the rounding direction.
        //:
        //: o Otherwise initialize this object to 'value' with exponent 0.

    //! Decimal128_Type(const Decimal128_Type& original) = default;
        // Create a 'Decimal128_Type' object that is a copy of the specified
        // 'original' as defined by the 'copy' operation of IEEE-754 2008:
        //
        //: o If 'original' is NaN, initialize this object to a NaN.
        //:
        //: o Otherwise initialize this object to the value of the 'original'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that a copy of a decimal will not compare equal to the original;
        // however it will behave as the original.

    //! ~Decimal128_Type() = default;
        // Destroy this object.

    // MANIPULATORS
    //! Decimal128_Type& operator=(const Decimal128_Type& rhs) = default;
        // Make this object a copy of the specified 'rhs' as defined by the
        // 'copy' operation of IEEE-754 2008 and return a reference providing
        // modifiable access to this object.
        //
        //: o If 'rhs' is NaN, set this object to a NaN.
        //:
        //: o Otherwise set this object to the value of the 'other'.
        //
        // Note that since floating-point types may be NaN, and NaNs are
        // unordered (do not compare equal even to themselves) it is possible
        // that, after an assignment, a decimal will not compare equal to the
        // original; however it will behave as the original.

    Decimal_Type128& operator++();
        // Add 1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to 1.0 (if the original value is small).

    Decimal_Type128& operator--();
        // Add -1.0 to the value of this object and return a reference to it.
        // Note that this is a floating-point value so this operation may not
        // change the value of this object at all (if the value is large) or it
        // may just set it to -1.0 (if the original value is small).

    Decimal_Type128& operator+=(Decimal32  rhs);
    Decimal_Type128& operator+=(Decimal64  rhs);
    Decimal_Type128& operator+=(Decimal128 rhs);
        // Add the value of the specified 'rhs' object to the value of this as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinity value of
        //:   differing signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinite values of the
        //:   same sign, then do not change this object.
        //:
        //: o Otherwise if 'rhs' has a zero value (positive or negative), do
        //:   not change this object.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the sum of the number represented by
        //:   'rhs' and the number represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type128& operator+=(int                rhs);
    Decimal_Type128& operator+=(unsigned int       rhs);
    Decimal_Type128& operator+=(long               rhs);
    Decimal_Type128& operator+=(unsigned long      rhs);
    Decimal_Type128& operator+=(long long          rhs);
    Decimal_Type128& operator+=(unsigned long long rhs);
        // Add the specified 'rhs' to the value of this object as described by
        // IEEE-754, store the result in this object, and return a reference to
        // this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if the sum of this object and 'rhs' has an absolute
        //:   value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to sum of adding 'rhs' and the number
        //:   represented by this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type128& operator-=(Decimal32  rhs);
    Decimal_Type128& operator-=(Decimal64  rhs);
    Decimal_Type128& operator-=(Decimal128 rhs);
        // Subtract the value of the specified 'rhs' from the value of this
        // object as described by IEEE-754, store the result in this object,
        // and return a reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' have infinity value of the
        //:   same signs, store the value of the macro 'EDOM' into 'errno'
        //:   and set this object to a NaN.
        //:
        //: o Otherwise if this object and the 'rhs' have infinite values of
        //:   differing signs, then do not change this object.
        //:
        //: o Otherwise if the 'rhs' has a zero value (positive or negative),
        //:   do not change this object.
        //:
        //: o Otherwise if subtracting the value of the 'rhs' object from this
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting the value
        //:   of 'rhs' from the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type128& operator-=(int                rhs);
    Decimal_Type128& operator-=(unsigned int       rhs);
    Decimal_Type128& operator-=(long               rhs);
    Decimal_Type128& operator-=(unsigned long      rhs);
    Decimal_Type128& operator-=(long long          rhs);
    Decimal_Type128& operator-=(unsigned long long rhs);
        // Subtract the specified 'rhs' from the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity, then do not change it.
        //:
        //: o Otherwise if subtracting 'rhs' from this object's value results
        //:   in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the result of subtracting 'rhs' from
        //:   the value of this object.
        //
        // Note that this is a floating-point value so this operations may not
        // change the value of this object at all (if the value is large) or it
        // may seem to update it to the value of the 'other' (if the original
        // value is small).

    Decimal_Type128& operator*=(Decimal32  rhs);
    Decimal_Type128& operator*=(Decimal64  rhs);
    Decimal_Type128& operator*=(Decimal128 rhs);
        // Multiply the value of the specified 'rhs' object by the value of
        // this as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise, if one of this object and 'rhs' is zero (positive or
        //:   negative) and the other is infinity (positive or negative), store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise, if either this object or 'rhs' is positive or negative
        //:   infinity, set this object to infinity.  The sign of this object
        //:   will be positive if this object and 'rhs' had the same sign, and
        //:   negative otherwise.
        //:
        //: o Otherwise, if either this object or 'rhs' is zero, set this
        //:   object to zero.  The sign of this object will be positive if this
        //:   object and 'rhs' had the same sign, and negative otherwise.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign of that result.
        //:
        //: o Otherwise if the product of this object and 'rhs' has an absolute
        //:   value that is smaller than
        //:   'std::numeric_limits<Decimal128>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero value
        //:   with the same sign as that result.
        //:
        //: o Otherwise set this object to the product of the value of 'rhs'
        //:   and the value of this object.

    Decimal_Type128& operator*=(int                rhs);
    Decimal_Type128& operator*=(unsigned int       rhs);
    Decimal_Type128& operator*=(long               rhs);
    Decimal_Type128& operator*=(unsigned long      rhs);
    Decimal_Type128& operator*=(long long          rhs);
    Decimal_Type128& operator*=(unsigned long long rhs);
        // Multiply the specified 'rhs' by the value of this object as
        // described by IEEE-754, store the result in this object, and return a
        // reference to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN, then do not change this object.
        //:
        //: o Otherwise if this object is infinity (positive or negative), and
        //:   'rhs' is zero, then store the value of the macro 'EDOM' into
        //:   'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative), then
        //:   do not change it.
        //:
        //: o Otherwise if 'rhs' is zero, then set this object to zero with the
        //:   same sign as its value had prior to this operation.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to infinity
        //:   with the same sign as that result.
        //:
        //: o Otherwise if the product of 'rhs' and the value of this object
        //:   results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal128>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and set this object to zero with
        //:   the same sign as that result.
        //:
        //: o Otherwise set this object to the product of the value of this
        //:   object and the value 'rhs'.

    Decimal_Type128& operator/=(Decimal32  rhs);
    Decimal_Type128& operator/=(Decimal64  rhs);
    Decimal_Type128& operator/=(Decimal128 rhs);
        // Divide the value of this object by the value of the specified 'rhs'
        // as described by IEEE-754, store the result in this object, and
        // return a reference to this object.
        //
        //: o If either of this object or 'rhs' is signaling NaN, then store
        //:   the value of the macro 'EDOM' into 'errno' and set this object to
        //:   a NaN.
        //:
        //: o Otherwise if either of this object or 'rhs' is NaN then set this
        //:   object to a NaN.
        //:
        //: o Otherwise if this object and 'rhs' are both infinity (positive or
        //:   negative) or both zero (positive or negative) then store the
        //:   value of the macro 'EDOM' into 'errno' and return a NaN.
        //:
        //: o Otherwise if 'rhs' has a positive zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the same sign as its original value.
        //:
        //: o Otherwise if 'rhs' has a negative zero value, then store the
        //:   value of the macro 'ERANGE' into 'errno' and set this object to
        //:   infinity with the opposite sign as its original value.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal128>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.

    Decimal_Type128& operator/=(int                rhs);
    Decimal_Type128& operator/=(unsigned int       rhs);
    Decimal_Type128& operator/=(long               rhs);
    Decimal_Type128& operator/=(unsigned long      rhs);
    Decimal_Type128& operator/=(long long          rhs);
    Decimal_Type128& operator/=(unsigned long long rhs);
        // Divide the value of this object by the specified 'rhs' as described
        // by IEEE-754, store the result in this object, and return a reference
        // to this object.
        //
        //: o If this object is signaling NaN, then store the value of the
        //:   macro 'EDOM' into 'errno' and set this object to a NaN.
        //:
        //: o Otherwise if this object is NaN then set this object to a NaN.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is positive value then set this object to infinity value
        //:   with the same sign as its original value.
        //:
        //: o Otherwise if this object is infinity (positive or negative) and
        //:   'rhs' is negative value then set this object to infinity value
        //:   with the opposite sign as its original value.
        //:
        //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
        //:   into 'errno' and set this object to infinity with the same sign
        //:   it had prior to this operation.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is larger than
        //:   'std::numeric_limits<Decimal128>::max()' then store the value of
        //:   the macro 'ERANGE' into 'errno' and return infinity with the same
        //:   sign as that result.
        //:
        //: o Otherwise if dividing the value of this object by the value of
        //:   'rhs' results in an absolute value that is smaller than
        //:   'std::numeric_limits<Decimal128>::min()' then store the value of
        //:   the macro 'ERANGE' into 'errno'and return zero with the same sign
        //:   as that result.
        //:
        //: o Otherwise set this object to the result of dividing the value of
        //:   this object by the value of 'rhs'.

    DecimalImpUtil::ValueType128 *data();
        // Return a modifiable pointer to the underlying implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamIn(STREAM& stream, int version);
        // Assign to this object the value read from the specified input
        // 'stream' using the specified 'version' format, and return a
        // reference to 'stream'.  If 'stream' is initially invalid, this
        // operation has no effect.  If 'version' is not supported, this object
        // is unaltered and 'stream' is invalidated, but otherwise unmodified.
        // If 'version' is supported but 'stream' becomes invalid during this
        // operation, this object has an undefined, but valid, state.  Note
        // that no version is read from 'stream'.  See the 'bslx' package-level
        // documentation for more information on BDEX streaming of
        // value-semantic types and containers.

    // ACCESSORS
    const DecimalImpUtil::ValueType128 *data() const;
        // Return a non-modifiable pointer to the underlying implementation.

    DecimalImpUtil::ValueType128 value() const;
        // Return the value of the underlying implementation.

                                  // Aspects

    template <class STREAM>
    STREAM& bdexStreamOut(STREAM& stream, int version) const;
        // Write the value of this object, using the specified 'version'
        // format, to the specified output 'stream', and return a reference to
        // 'stream'.  If 'stream' is initially invalid, this operation has no
        // effect.  If 'version' is not supported, 'stream' is invalidated, but
        // otherwise unmodified.  Note that 'version' is not written to
        // 'stream'.  See the 'bslx' package-level documentation for more
        // information on BDEX streaming of value-semantic types and
        // containers.
};

// FREE OPERATORS
Decimal128 operator+(Decimal128 value);
    // Return a copy of the specified 'value' if the value is not negative
    // zero, and return positive zero otherwise.

Decimal128 operator-(Decimal128 value);
    // Return the result of applying the unary - operator to the specified
    // 'value' as described by IEEE-754.  Note that floating-point numbers have
    // signed zero, therefore this operation is not the same as '0-value'.

Decimal128 operator++(Decimal128& value, int);
    // Apply the prefix ++ operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operations may not change the value of this object at all (if the value
    // is large) or it may just set it to 1.0 (if the original value is small).

Decimal128 operator--(Decimal128& value, int);
    // Apply the prefix -- operator to the specified 'value' and return its
    // original value.  Note that this is a floating-point value so this
    // operations may not change the value of this object at all (if the value
    // is large) or it may just set it to -1.0 (if the original value is
    // small).

Decimal128 operator+(Decimal128 lhs, Decimal128 rhs);
Decimal128 operator+(Decimal32  lhs, Decimal128 rhs);
Decimal128 operator+(Decimal128 lhs, Decimal32  rhs);
Decimal128 operator+(Decimal64  lhs, Decimal128 rhs);
Decimal128 operator+(Decimal128 lhs, Decimal64  rhs);
    // Add the value of the specified 'rhs' to the value of the specified 'lhs'
    // as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of differing signs, store
    //:   the value of the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are infinities of the same sign then
    //:   return infinity of that sign.
    //:
    //: o Otherwise if 'rhs' is zero (positive or negative), return 'lhs'.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal128>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and set this object to
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the sum of the number represented by 'lhs' and the
    //:   number represented by 'rhs'.

Decimal128 operator+(Decimal128 lhs, int                rhs);
Decimal128 operator+(Decimal128 lhs, unsigned int       rhs);
Decimal128 operator+(Decimal128 lhs, long               rhs);
Decimal128 operator+(Decimal128 lhs, unsigned long      rhs);
Decimal128 operator+(Decimal128 lhs, long long          rhs);
Decimal128 operator+(Decimal128 lhs, unsigned long long rhs);
    // Add the specified 'rhs' to the value of the specified 'lhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal128>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'rhs' and the number represented by
    //:   'lhs'.

Decimal128 operator+(int                lhs, Decimal128 rhs);
Decimal128 operator+(unsigned int       lhs, Decimal128 rhs);
Decimal128 operator+(long               lhs, Decimal128 rhs);
Decimal128 operator+(unsigned long      lhs, Decimal128 rhs);
Decimal128 operator+(long long          lhs, Decimal128 rhs);
Decimal128 operator+(unsigned long long lhs, Decimal128 rhs);
    // Add the specified 'lhs' to the value of the specified 'rhs' as described
    // by IEEE-754 and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' object is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if the sum of 'lhs' and 'rhs' has an absolute value that is
    //:   larger than 'std::numeric_limits<Decimal128>::max()' then store the
    //:   value of the macro 'ERANGE' into 'errno' and return infinity with the
    //:   same sign as that result.
    //:
    //: o Otherwise return the sum of 'lhs' and the number represented by
    //:   'rhs'.

Decimal128 operator-(Decimal128 lhs, Decimal128 rhs);
Decimal128 operator-(Decimal32  lhs, Decimal128 rhs);
Decimal128 operator-(Decimal128 lhs, Decimal32  rhs);
Decimal128 operator-(Decimal64  lhs, Decimal128 rhs);
Decimal128 operator-(Decimal128 lhs, Decimal64  rhs);
    // Subtract the value of the specified 'rhs' from the value of the
    // specified 'lhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of the same
    //:   sign, store the value of the macro 'EDOM' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'lhs' and the 'rhs' have infinity values of differing
    //:   signs, then return 'lhs'.
    //:
    //: o Otherwise if the subtracting of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal128>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs'from the
    //:   value of 'lhs'.

Decimal128 operator-(Decimal128 lhs, int                rhs);
Decimal128 operator-(Decimal128 lhs, unsigned int       rhs);
Decimal128 operator-(Decimal128 lhs, long               rhs);
Decimal128 operator-(Decimal128 lhs, unsigned long      rhs);
Decimal128 operator-(Decimal128 lhs, long long          rhs);
Decimal128 operator-(Decimal128 lhs, unsigned long long rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting 'rhs' from the value of
    //:   'lhs'.

Decimal128 operator-(int                lhs, Decimal128 rhs);
Decimal128 operator-(unsigned int       lhs, Decimal128 rhs);
Decimal128 operator-(long               lhs, Decimal128 rhs);
Decimal128 operator-(unsigned long      lhs, Decimal128 rhs);
Decimal128 operator-(long long          lhs, Decimal128 rhs);
Decimal128 operator-(unsigned long long lhs, Decimal128 rhs);
    // Subtract the specified 'rhs' from the value of the specified 'lhs' as
    // described by IEEE-754 and return a reference to this object.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity, then return infinity.
    //:
    //: o Otherwise if subtracting 'rhs' from 'lhs' object's value results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of subtracting the value of 'rhs' from
    //:   the number 'lhs'.

Decimal128 operator*(Decimal128 lhs, Decimal128 rhs);
Decimal128 operator*(Decimal32  lhs, Decimal128 rhs);
Decimal128 operator*(Decimal128 lhs, Decimal32  rhs);
Decimal128 operator*(Decimal64  lhs, Decimal128 rhs);
Decimal128 operator*(Decimal128 lhs, Decimal64  rhs);
    // Multiply the value of the specified 'lhs' object by the value of the
    // specified 'rhs' as described by IEEE-754 and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if one of the operands is infinity (positive or negative)
    //:   and the other is zero (positive or negative), then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if both 'lhs' and 'rhs' are infinity (positive or
    //:   negative), return infinity.  The sign of the returned value will be
    //:   positive if 'lhs' and 'rhs' have the same sign, and negative
    //:   otherwise.
    //:
    //: o Otherwise, if either 'lhs' or 'rhs' is zero, return zero.  The sign
    //:   of the returned value will be positive if 'lhs' and 'rhs' have the
    //:   same sign, and negative otherwise.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is larger than 'std::numeric_limits<Decimal128>::max()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return an
    //:   infinity with the same sign as that result.
    //:
    //: o Otherwise if the product of 'lhs' and 'rhs' has an absolute value
    //:   that is smaller than 'std::numeric_limits<Decimal128>::min()' then
    //:   store the value of the macro 'ERANGE' into 'errno' and return zero
    //:   with the same sign as that result.
    //:
    //: o Otherwise return the product of the value of 'rhs' and the number
    //:   represented by 'rhs'.

Decimal128 operator*(Decimal128 lhs, int                rhs);
Decimal128 operator*(Decimal128 lhs, unsigned int       rhs);
Decimal128 operator*(Decimal128 lhs, long               rhs);
Decimal128 operator*(Decimal128 lhs, unsigned long      rhs);
Decimal128 operator*(Decimal128 lhs, long long          rhs);
Decimal128 operator*(Decimal128 lhs, unsigned long long rhs);
    // Multiply the specified 'rhs' by the value of the specified 'lhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), and 'rhs' is
    //:   zero, then store the value of the macro 'EDOM' into'errno' and return
    //:   a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative), then return
    //:   'lhs'.
    //:
    //: o Otherwise if 'rhs' is zero, then return zero with the sign of 'lhs'.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'rhs' and the value of 'lhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal128>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal128 operator*(int                lhs, Decimal128 rhs);
Decimal128 operator*(unsigned int       lhs, Decimal128 rhs);
Decimal128 operator*(long               lhs, Decimal128 rhs);
Decimal128 operator*(unsigned long      lhs, Decimal128 rhs);
Decimal128 operator*(long long          lhs, Decimal128 rhs);
Decimal128 operator*(unsigned long long lhs, Decimal128 rhs);
    // Multiply the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN, then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, then store the value of the macro 'EDOM' into'errno' and return
    //:   a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), then return
    //:   'rhs'.
    //:
    //: o Otherwise if 'lhs' is zero, then return zero with the sign of 'rhs'.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if the product of 'lhs' and the value of 'rhs' results in
    //:   an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal128>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the product of the value of 'lhs' and value 'rhs'.

Decimal128 operator/(Decimal128 lhs, Decimal128 rhs);
Decimal128 operator/(Decimal32  lhs, Decimal128 rhs);
Decimal128 operator/(Decimal128 lhs, Decimal32  rhs);
Decimal128 operator/(Decimal64  lhs, Decimal128 rhs);
Decimal128 operator/(Decimal128 lhs, Decimal64  rhs);
    // Divide the value of the specified 'lhs' by the value of the specified
    // 'rhs' as described by IEEE-754, and return the result.
    //
    //: o If either of 'lhs' or 'rhs' is signaling NaN, then store the value of
    //:   the macro 'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if either of 'lhs' or 'rhs' is NaN, return a NaN.
    //:
    //: o Otherwise if 'lhs' and 'rhs' are both infinity (positive or negative)
    //:   or both zero (positive or negative) then store the value of the macro
    //:   'EDOM' into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a positive zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has a normal value and 'rhs' has a negative zero
    //:   value, store the value of the macro 'ERANGE' into 'errno' and return
    //:   infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a positive zero
    //:   value, return infinity with the sign of 'lhs'.
    //:
    //: o Otherwise if 'lhs' has infinity value and 'rhs' has a negative zero
    //:   value, return infinity with the opposite sign as 'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal128>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.

Decimal128 operator/(Decimal128 lhs, int                rhs);
Decimal128 operator/(Decimal128 lhs, unsigned int       rhs);
Decimal128 operator/(Decimal128 lhs, long               rhs);
Decimal128 operator/(Decimal128 lhs, unsigned long      rhs);
Decimal128 operator/(Decimal128 lhs, long long          rhs);
Decimal128 operator/(Decimal128 lhs, unsigned long long rhs);
    // Divide the value of the specified 'lhs' by the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'lhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'lhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   positive value then return infinity value with the same sign as its
    //:   original value.
    //:
    //: o Otherwise if 'lhs' is infinity (positive or negative) and 'rhs' is
    //:   negative value then return infinity value with the opposite sign as
    //:   its original value.
    //:
    //: o Otherwise if 'rhs' is zero, store the value of the macro 'ERANGE'
    //:   into 'errno' and return infinity with the same sign it had prior to
    //:   this operation.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal128>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.

Decimal128 operator/(int                lhs, Decimal128 rhs);
Decimal128 operator/(unsigned int       lhs, Decimal128 rhs);
Decimal128 operator/(long               lhs, Decimal128 rhs);
Decimal128 operator/(unsigned long      lhs, Decimal128 rhs);
Decimal128 operator/(long long          lhs, Decimal128 rhs);
Decimal128 operator/(unsigned long long lhs, Decimal128 rhs);
    // Divide the specified 'lhs' by the value of the specified 'rhs' as
    // described by IEEE-754, and return the result.
    //
    //: o If 'rhs' is signaling NaN, then store the value of the macro 'EDOM'
    //:   into 'errno' and return a NaN.
    //:
    //: o Otherwise if 'rhs' is NaN then return a NaN.
    //:
    //: o Otherwise if 'rhs' is infinity (positive or negative), and 'lhs' is
    //:   zero, store the value of the macro 'ERANGE' into 'errno' and return a
    //:   NaN.
    //:
    //: o Otherwise if 'rhs' is zero (positive or negative), store the value of
    //:   the macro 'ERANGE' into 'errno' and return infinity with the sign of
    //:   'lhs'.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is larger than
    //:   'std::numeric_limits<Decimal128>::max()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return infinity with the same sign as
    //:   that result.
    //:
    //: o Otherwise if dividing the value of 'lhs' by the value of 'rhs'
    //:   results in an absolute value that is smaller than
    //:   'std::numeric_limits<Decimal128>::min()' then store the value of the
    //:   macro 'ERANGE' into 'errno' and return zero with the same sign as
    //:   that result.
    //:
    //: o Otherwise return the result of dividing the value of 'lhs' by the
    //:   value of 'rhs'.  Note that this is a floating-point operation, not
    //:   integer.

bool operator==(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' have the same value, and
    // 'false' otherwise.  Two 'Decimal128' objects have the same value if the
    // 'compareQuietEqual' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representations equal.  In
    // other words, two 'Decimal128' objects have the same value if:
    //
    //: o both have a zero value (positive or negative), or
    //: o both have the same infinity value (both positive or negative), or
    //: o both have the value of a real number that are equal, even if they are
    //:   represented differently (cohorts have the same value)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal128 aNaN = std::numeric_limits<Decimal128>::quiet_NaN();
    //  assert(!(aNan == aNan));
    //..

bool operator==(Decimal32  lhs, Decimal128 rhs);
bool operator==(Decimal128 lhs, Decimal32  rhs);
bool operator==(Decimal64  lhs, Decimal128 rhs);
bool operator==(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' have the same value, and
    // 'false' otherwise.  Two decimal objects have the same value if the
    // 'compareQuietEqual' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representations equal.  In
    // other words, two decimal objects have the same value if:
    //
    //: o both have a zero value (positive or negative), or
    //: o both have the same infinity value (both positive or negative), or
    //: o both have the value of a real number that are equal, even if they are
    //:   represented differently (cohorts have the same value)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator!=(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' do not have the same
    // value, and 'false' otherwise.  Two 'Decimal128' objects do not have the
    // same value if the 'compareQuietEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representations not equal.  In other words, two 'Decimal128' objects do
    // not have the same value if:
    //
    //: o both are a NaN, or
    //: o one has zero value (positive or negative) and the other does not, or
    //: o one has the value of positive infinity and the other does not, or
    //: o one has the value of negative infinity and the other does not, or
    //: o both have the value of a real number that are not equal, regardless
    //:   of their representation (cohorts are equal)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.
    //
    // Note that a NaN is never equal to anything, including itself:
    //..
    //  Decimal128 aNaN = std::numeric_limits<Decimal128>::quiet_NaN();
    //  assert(aNan != aNan);
    //..

bool operator!=(Decimal32  lhs, Decimal128 rhs);
bool operator!=(Decimal128 lhs, Decimal32  rhs);
bool operator!=(Decimal64  lhs, Decimal128 rhs);
bool operator!=(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' and 'rhs' do not have the same
    // value, and 'false' otherwise.  Two decimal objects do not have the same
    // value if the 'compareQuietEqual' operation (IEEE-754 defined, non-total
    // ordering comparison) considers the underlying IEEE representations not
    // equal.  In other words, two decimal objects do not have the same value
    // if:
    //
    //: o both are NaN, or
    //: o one has zero value (positive or negative) and the other does not, or
    //: o one has the value of positive infinity and the other does not, or
    //: o one has the value of negative infinity and the other does not, or
    //: o both have the value of a real number that are not equal, regardless
    //:   of their representation (cohorts are equal)
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' has a value less than the specified
    // 'rhs' and 'false' otherwise.  The value of a 'Decimal128' object 'lhs'
    // is less than that of an object 'rhs' if the 'compareQuietLess' operation
    // (IEEE-754 defined, non-total ordering comparison) considers the
    // underlying IEEE representation of 'lhs' to be less than of that of
    // 'rhs'.  In other words, 'lhs' is less than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' is positive, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' negative, or
    //: o 'lhs' is not positive infinity, or
    //: o 'lhs' is negative infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<(Decimal32  lhs, Decimal128 rhs);
bool operator<(Decimal128 lhs, Decimal32  rhs);
bool operator<(Decimal64  lhs, Decimal128 rhs);
bool operator<(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' has a value less than the specified
    // 'rhs' and 'false' otherwise.  The value of a decimal object 'lhs' is
    // less than that of an object 'rhs' if the 'compareQuietLess' operation
    // (IEEE-754 defined, non-total ordering comparison) considers the
    // underlying IEEE representation of 'lhs' to be less than of that of
    // 'rhs'.  In other words, 'lhs' is less than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' is positive, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' negative, or
    //: o 'lhs' is not positive infinity, or
    //: o 'lhs' is negative infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs'is less than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<=(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' has a value less than or equal the
    // value of the specified 'rhs' and 'false' otherwise.  The value of a
    // 'Decimal128' object 'lhs' is less than or equal to the value of an
    // object 'rhs' if the 'compareQuietLessEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representation of 'lhs' to be less or equal to that of 'rhs'.  In other
    // words, 'lhs' is less or equal than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are positive infinity, or
    //: o 'lhs' is negative infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator<=(Decimal32  lhs, Decimal128 rhs);
bool operator<=(Decimal128 lhs, Decimal32  rhs);
bool operator<=(Decimal64  lhs, Decimal128 rhs);
bool operator<=(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' has a value less than or equal the
    // value of the specified 'rhs' and 'false' otherwise.  The value of a
    // decimal object 'lhs' is less than or equal to the value of an object
    // 'rhs' if the 'compareQuietLessEqual' operation (IEEE-754 defined,
    // non-total ordering comparison) considers the underlying IEEE
    // representation of 'lhs' to be less or equal to that of 'rhs'.  In other
    // words, 'lhs' is less or equal than 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are positive infinity, or
    //: o 'lhs' is negative infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is less or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' has a greater value than the
    // specified 'rhs' and 'false' otherwise.  The value of a 'Decimal128'
    // object 'lhs' is greater than that of an object 'rhs' if the
    // 'compareQuietGreater' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representation of 'lhs' to be
    // greater than of that of 'rhs'.  In other words, 'lhs' is greater than
    // 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' positive, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' negative, or
    //: o 'lhs' is not negative infinity, or
    //: o 'lhs' is positive infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>(Decimal32  lhs, Decimal128 rhs);
bool operator>(Decimal128 lhs, Decimal32  rhs);
bool operator>(Decimal64  lhs, Decimal128 rhs);
bool operator>(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' has a greater value than the
    // specified 'rhs' and 'false' otherwise.  The value of a decimal object
    // 'lhs' is greater than that of an object 'rhs' if the
    // 'compareQuietGreater' operation (IEEE-754 defined, non-total ordering
    // comparison) considers the underlying IEEE representation of 'lhs' to be
    // greater than of that of 'rhs'.  In other words, 'lhs' is greater than
    // 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'rhs' is zero (positive or negative) and 'lhs' positive, or
    //: o 'lhs' is zero (positive or negative) and 'rhs' negative, or
    //: o 'lhs' is not negative infinity, or
    //: o 'lhs' is positive infinity and 'rhs' is not, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater than that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>=(Decimal128 lhs, Decimal128 rhs);
    // Return 'true' if the specified 'lhs' has a value greater than or equal
    // to the value of the specified 'rhs' and 'false' otherwise.  The value of
    // a 'Decimal128' object 'lhs' is greater or equal to a 'Decimal128' object
    // 'rhs' if the 'compareQuietGreaterEqual' operation (IEEE-754 defined,
    // non-total ordering comparison ) considers the underlying IEEE
    // representation of 'lhs' to be greater or equal to that of 'rhs'.  In
    // other words, 'lhs' is greater than or equal to 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are negative infinity, or
    //: o 'lhs' is positive infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

bool operator>=(Decimal32  lhs, Decimal128 rhs);
bool operator>=(Decimal128 lhs, Decimal32  rhs);
bool operator>=(Decimal64  lhs, Decimal128 rhs);
bool operator>=(Decimal128 lhs, Decimal64  rhs);
    // Return 'true' if the specified 'lhs' has a value greater than or equal
    // to the value of the specified 'rhs' and 'false' otherwise.  The value of
    // a decimal object 'lhs' is greater or equal to a decimal object 'rhs' if
    // the 'compareQuietGreaterEqual' operation (IEEE-754 defined, non-total
    // ordering comparison ) considers the underlying IEEE representation of
    // 'lhs' to be greater or equal to that of 'rhs'.  In other words, 'lhs' is
    // greater than or equal to 'rhs' if:
    //
    //: o neither 'lhs' nor 'rhs' are NaN, or
    //: o 'lhs' and 'rhs' are both zero (positive or negative), or
    //: o both 'lhs' and 'rhs' are negative infinity, or
    //: o 'lhs' is positive infinity, or
    //: o 'lhs' and 'rhs' both represent a real number and the real number of
    //:   'lhs' is greater or equal to that of 'rhs'
    //
    // This operation stores the value of the macro 'EDOM' into 'errno' if
    // either or both operands are signaling NaN.

template <class CHARTYPE, class TRAITS>
bsl::basic_istream<CHARTYPE, TRAITS>&
operator>> (bsl::basic_istream<CHARTYPE, TRAITS>& stream, Decimal128& object);
    // Read, into the specified 'object', from the specified input 'stream' an
    // IEEE 128 bit decimal floating-point value as described in the IEEE-754
    // 2008 standard (5.12 Details of conversions between floating point
    // numbers and external character sequences) and return a reference
    // providing modifiable access to 'stream'.  If 'stream' contains a Nan
    // value, it is unspecified if 'object' will receive a quiet or signaling
    // 'Nan'.  If 'stream' is not valid on entry 'stream.good() == false', this
    // operation has no effect other than setting 'stream.fail()' to 'true'.
    // If eof (end-of-file) is found before any non-whitespace characters
    // 'stream.fail()' is set to 'true' and 'object' remains unchanged.  If eof
    // is detected after some characters have been read (and successfully
    // interpreted as part of the textual representation of a floating-point
    // value as specified by IEEE-754) then 'stream.eof()' is set to true.  If
    // the first non-whitespace character sequence is not a valid textual
    // representation of a floating-point value (e.g., 12e or e12 or 1*2) the
    // 'stream.fail()' is set to true and 'object' will remain unchanged.  If a
    // real number value is represented by the character sequence but it is a
    // large positive or negative value that cannot be stored into 'object'
    // then store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative infinity is stored into 'object', respectively.  If a real
    // number value is represented by the character sequence but it is a small
    // positive or negative value that cannot be stored into 'object' then
    // store the value of the macro 'ERANGE' into 'errno' and positive or
    // negative zero is stored into 'object', respectively.  If a real number
    // value is represented by the character sequence but it cannot be stored
    // exactly into 'object', the value is rounded according to the current
    // rounding direction (of the environment) and then stored into 'object'.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

template <class CHARTYPE, class TRAITS>
bsl::basic_ostream<CHARTYPE, TRAITS>&
operator<< (bsl::basic_ostream<CHARTYPE, TRAITS>& stream, Decimal128 object);
    // Write the value of the specified 'object' to the specified output
    // 'stream' in a single line format as described in the IEEE-754 2008
    // standard (5.12 Details of conversions between floating point numbers and
    // external character sequences), and return a reference providing
    // modifiable access to 'stream'.  If 'stream' is not valid on entry, this
    // operation has no effect.
    //
    // NOTE: This method does not yet fully support iostream flags or the
    // decimal floating point exception context.

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline namespace literals {
inline namespace DecimalLiterals {
bdldfp::Decimal128 operator "" _d128(const char *str);
bdldfp::Decimal128 operator "" _d128(const char *str, bsl::size_t len);
    // Produce an object of the indicated return type by parsing the specified
    // 'str' having the specified 'len' excluding the terminating null
    // character that represents a floating-point number written in both fixed
    // and scientific notations.  These user-defined literal suffixes can be
    // applied to both numeric and string literals, (i.e., 1.2_d128, "1.2"_d128
    // or "inf"_d128). The resulting decimal object is initialized as follows:
    //
    //: o If 'str' does not represent a floating-point value, then return a
    //:   decimal object of the indicated return type initialized to a NaN.
    //:
    //: o Otherwise if 'str' represents infinity (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   infinity value with the same sign.
    //:
    //: o Otherwise if 'str' represents zero (positive or negative), then
    //:   return a decimal object of the indicated return type initialized to
    //:   zero with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is larger than the maximum value supported by the indicated return
    //:   type, then store the value of the macro 'ERANGE' into 'errno' and
    //:   return a decimal object of the return type initialized to infinity
    //:   with the same sign.
    //:
    //: o Otherwise if 'str' represents a value that has an absolute value that
    //:   is smaller than min value of the indicated return type, then store
    //:   the value of the macro 'ERANGE' into 'errno' and return a decimal
    //:   object of the return type initialized to zero with the same sign.
    //:
    //: o Otherwise if 'str' has a value that is not exactly representable
    //:   using the maximum digit number supported by the indicated return
    //:   type, then return a decimal object of the return type initialized to
    //:   the value represented by 'str' rounded according to the rounding
    //:   direction.
    //:
    //: o Otherwise return a decimal object of the indicated return type
    //:   initialized to the decimal value representation of 'str'.
    //
    // Note that the parsing follows the rules as specified for the 'strtod128'
    // function in section 9.6 of the ISO/EIC TR 247128 C Decimal
    // Floating-Point Technical Report.
    //
    // Also note that the numeric literal version omits the optional leading
    // sign in 'str'.  For example, if the string is -1.2_d128 then the string
    // "1.2" is passed to the one-argument form, not "-1.2", because leading
    // signs are operators, not parts of literals.  On the other hand, the
    // string literal version does not omit leading sign and if the string is
    // "-1.2"_d128 then the string "-1.2" is passed to the two-argument form.
    //
    // Also note that the quantum of the resultant value is affected by the
    // number of decimal places in 'str' string in both numeric and string
    // literal formats starting with the most significand digit and cannot
    // exceed the maximum number of digits necessary to differentiate all
    // values of the indicated return type, for example:
    //
    // '0.015_d128;                  =>                                 15e-3'
    // '1.5_d128;                    =>                                 15e-1'
    // '1.500_d128;                  =>                               1500e-3'
    // '1.2345678901234567890123456789012349_d128;
    //                               => 1234567890123456789012345678901235e-33'

}  // close DecimalLiterals namespace
}  // close literals namespace
#endif

// FREE FUNCTIONS
template <class HASHALG>
void hashAppend(HASHALG& hashAlg, const Decimal128& object);
    // Pass the specified 'object' to the specified 'hashAlg'.  This function
    // integrates with the 'bslh' modular hashing system and effectively
    // provides a 'bsl::hash' specialization for 'Decimal128'.  Note that two
    // objects which have the same value but different representations will
    // hash to the same value.

                        // MISCELLANEOUS RELATED TYPES

                          // ===================
                          // class DecimalNumGet
                          // ===================

template <class CHARTYPE,
          class INPUTITERATOR = bsl::istreambuf_iterator<CHARTYPE> >
class DecimalNumGet : public bsl::locale::facet {
    // A facet type (mechanism) used in reading decimal floating-point types.
    // Note that this type does not follow BDE conventions because its content
    // is dictated by the C++ standard and native standard library
    // implementations.  See ISO/IEC TR 24733 3.10.2 for details.

#if defined(BSLS_LIBRARYFEATURES_STDCPP_LIBCSTD)
  private:
    // ACCESSORS
    bsl::locale::id& __get_id() const;
         // The function __get_id() is a pure virtual function in the Rogue
         // Wave implementation of locales.  It is in violation with the
         // standard.  We have to define it as a workaround.
#endif

  public:
    // -dk:TODO make private while making the output operator a friend

    // CLASS METHODS
    static const DecimalNumGet<CHARTYPE, INPUTITERATOR>& object();
        // TBD

  public:
    // PUBLIC TYPES
    static bsl::locale::id id; // The locale identifier

    typedef CHARTYPE      char_type;
    typedef INPUTITERATOR iter_type;

    // CREATORS
    explicit DecimalNumGet(bsl::size_t refs = 0);
        // Constructs a 'DecimalNumGet' object.  Optionally specify starting
        // reference count 'refs', which will default to 0.  If 'refs' is
        // non-zero, the 'DecimalNumGet' object will not be deleted when the
        // last locale referencing it goes out of scope.

    // ACCESSORS
    iter_type get(iter_type               begin,
                  iter_type               end,
                  bsl::ios_base&          str,
                  bsl::ios_base::iostate& err,
                  Decimal32&              value) const;
    iter_type get(iter_type               begin,
                  iter_type               end,
                  bsl::ios_base&          str,
                  bsl::ios_base::iostate& err,
                  Decimal64&              value) const;
    iter_type get(iter_type               begin,
                  iter_type               end,
                  bsl::ios_base&          str,
                  bsl::ios_base::iostate& err,
                  Decimal128&             value) const;
        // Forward to, and return using the specified 'begin', 'end', 'str',
        // 'err', and 'value', the results of
        // 'this->do_get(begin, end, str, err, value)'.

  protected:
    // CREATORS
    ~DecimalNumGet();
        // Destroy this object.  Note that the destructor is virtual.

    // ACCESSORS
    virtual iter_type do_get(iter_type               begin,
                             iter_type               end,
                             bsl::ios_base&          str,
                             bsl::ios_base::iostate& err,
                             Decimal32&              value) const;
    virtual iter_type do_get(iter_type               begin,
                             iter_type               end,
                             bsl::ios_base&          str,
                             bsl::ios_base::iostate& err,
                             Decimal64&              value) const;
    virtual iter_type do_get(iter_type               begin,
                             iter_type               end,
                             bsl::ios_base&          str,
                             bsl::ios_base::iostate& err,
                             Decimal128&             value) const;
        // Interpret characters from the half-open iterator range denoted by
        // the specified 'begin' and 'end', generate a decimal floating-point
        // number and store it into the specified 'value'.  During conversion
        // the formatting flags of the specified 'str' ('str.flags()') are
        // obeyed; character classifications are determined by the 'bsl::ctype'
        // while punctuation characters are determined by the 'bsl::numpunct'
        // facet imbued to the 'str' stream-base.  Use the specified 'err' to
        // report back failure or EOF streams states.  For further, more
        // detailed information please consult the section
        // [lib.facet.num.get.virtuals] of the C++ Standard.  Note that for the
        // conversions to the 'Decimal32', 64 and 128 types the conversion
        // specifiers are %Hg, %Dg and %DDg, respectively.  Also note that
        // these (possibly overridden) 'do_get' virtual function are used by
        // every formatted C++ stream input operator call ('in >> aDecNumber').
};

                // ============================================
                // template <class CHARTYPE, bool WCHAR_8_BITS>
                // class WideBufferWrapper
                // ============================================

template <class CHARTYPE, bool WCHAR_8_BITS>
class DecimalNumPut_WideBufferWrapper;
    // This class provides a wrapper around a buffer of the specified (template
    // parameter) 'CHARTYPE'.  'CHARTYPE' shall be either plain character type
    // 'char' or wide character type 'wchar_t'.  The width of 'wchar_t' is
    // compiler-specific and can be as small as 8 bits.  The template parameter
    // 'WCHAR_8_BITS' shall be 'true' if 'wchar_t' and 'char' widths are the
    // same, i.e. 8 bits, and 'false' otherwise.  This class provides accessors
    // to the beginning and the end of the buffer of 'CHARTYPE' characters.

            // ========================================================
            // template <bool WCHAR_8_BIT>
            // class DecimalNumPut_WideBufferWrapper<char, WCHAR_8_BIT>
            // ========================================================

template <bool WCHAR_8_BIT>
class DecimalNumPut_WideBufferWrapper<char, WCHAR_8_BIT> {
    // This class is specialization of the template
    // 'WideBufferWrapper<CHARTYPE, WCHAR_8_BITS>' for 'char' type and
    // 'wchar_t' type which width is 8 bits.

    // DATA
    const char *d_begin;  // pointer to the beginning of plain character buffer
    const char *d_end;    // pointer to the end of plain character buffer

    // NOT IMPLEMENTED
    DecimalNumPut_WideBufferWrapper(const DecimalNumPut_WideBufferWrapper&);
    DecimalNumPut_WideBufferWrapper& operator=(
                                    const DecimalNumPut_WideBufferWrapper&);

  public:
    // CREATORS
    DecimalNumPut_WideBufferWrapper(const char         *buffer,
                                    int                 len,
                                    const bsl::locale&);
        // Create a wide buffer wrapper for the specified 'buffer' of the
        // specified length 'len'.

    // ACCESSORS
    const char *begin() const;
        // Return a pointer to the beginning of the buffer of plain characters
        // provided in this class constructor.

    const char *end() const;
        // Return a pointer to the end of the buffer of plain characters
        // provided in this class constructor.
};

            // =====================================================
            // template <>
            // class DecimalNumPut_WideBufferWrapper<wchar_t, false>
            // =====================================================

template <>
class DecimalNumPut_WideBufferWrapper<wchar_t, false> {
    // This class is specialization of the template
    // 'WideBufferWrapper<CHARTYPE, WCHAR_8_BIT>' for 'wchar_t' type which
    // width exceeds 8 bits.

    // DATA
    wchar_t *d_buffer_p;  // Buffer of wide characters
    size_t   d_len;       // Length of the buffer

    // NOT IMPLEMENTED
    DecimalNumPut_WideBufferWrapper(const DecimalNumPut_WideBufferWrapper&);
    DecimalNumPut_WideBufferWrapper& operator=(
                                    const DecimalNumPut_WideBufferWrapper&);

  public:
    // CREATORS
    inline
    DecimalNumPut_WideBufferWrapper(const char         *buffer,
                                    int                 len,
                                    const bsl::locale&  loc);
        // Create a wide buffer wrapper for the specified 'buffer' of the
        // specified length 'len'.  Use the specified locale 'loc' to widen
        // character in the buffer into wide characters representation.

    ~DecimalNumPut_WideBufferWrapper();
        // Destroy this object.

    // ACCESSORS
    const wchar_t *begin() const;
        // Return a pointer to the beginning of the buffer of wide characters.

    const wchar_t *end() const;
        // Return a pointer to the end the buffer of wide characters.
};

// ============================================================================
//                            INLINE DEFINITIONS
// ============================================================================

                // -------------------------------------------
                // class DecimalNumPut_WideBufferWrapper<char>
                // -------------------------------------------

//CREATORS
template <bool WCHAR_8_BIT>
inline
DecimalNumPut_WideBufferWrapper<char, WCHAR_8_BIT>::
DecimalNumPut_WideBufferWrapper(const char         *buffer,
                                int                 len,
                                const bsl::locale&)
: d_begin(buffer)
, d_end(buffer + len)
{
    BSLS_ASSERT(buffer);
    BSLS_ASSERT(len >= 0);
}

// ACCESSORS
template <bool WCHAR_8_BIT>
inline
const char *DecimalNumPut_WideBufferWrapper<char, WCHAR_8_BIT>::begin() const
{
    return d_begin;
}

template <bool WCHAR_8_BIT>
inline
const char *DecimalNumPut_WideBufferWrapper<char, WCHAR_8_BIT>::end() const
{
    return d_end;
}

                // ----------------------------------------------
                // class DecimalNumPut_WideBufferWrapper<wchar_t>
                // ----------------------------------------------

//CREATORS
inline
DecimalNumPut_WideBufferWrapper<wchar_t, false>::
DecimalNumPut_WideBufferWrapper(const char         *buffer,
                                int                 len,
                                const bsl::locale&  loc)
: d_buffer_p(0)
, d_len(len)
{
    BSLS_ASSERT(buffer);
    BSLS_ASSERT(len >= 0);

    bslma::Allocator *allocator = bslma::Default::allocator();

    d_buffer_p = (wchar_t *)allocator->allocate(sizeof(wchar_t) * len);

    bsl::use_facet<std::ctype<wchar_t> >(loc).widen(buffer,
                                                    buffer + len,
                                                    d_buffer_p);
}

inline
DecimalNumPut_WideBufferWrapper<wchar_t, false>::
~DecimalNumPut_WideBufferWrapper()
{
    bslma::Allocator *allocator = bslma::Default::allocator();
    allocator->deallocate(d_buffer_p);
}

    // ACCESSORS
inline
const wchar_t *DecimalNumPut_WideBufferWrapper<wchar_t, false>::begin() const
{
    return d_buffer_p;
}

inline
const wchar_t *DecimalNumPut_WideBufferWrapper<wchar_t, false>::end() const
{
    return d_buffer_p + d_len;
}

                          // ===================
                          // class DecimalNumPut
                          // ===================

template <class CHARTYPE,
          class OUTPUTITERATOR = bsl::ostreambuf_iterator<CHARTYPE> >
class DecimalNumPut : public bsl::locale::facet {
    // A facet type (mechanism) used in writing decimal floating-point types.
    // Note that this type does not follow BDE conventions because its content
    // is dictated by the C++ standard and native standard library
    // implementations.  See ISO/IEC TR 24733 3.10.3 for details.

#if defined(BSLS_LIBRARYFEATURES_STDCPP_LIBCSTD)
  private:
    // ACCESSORS
    bsl::locale::id& __get_id() const;
        // The function __get_id() is a pure virtual function in the Rogue Wave
        // implementation of locales.  It is in violation with the standard.
        // We have to define it as a workaround.
#endif

  public:
    // -dk:TODO make private while making the output operator a friend

    // CLASS METHODS
    static const DecimalNumPut<CHARTYPE, OUTPUTITERATOR>& object();
        // TBD

  public:
    // PUBLIC TYPES
    static bsl::locale::id id; // The locale identifier

    typedef CHARTYPE       char_type;
    typedef OUTPUTITERATOR iter_type;

    // CREATORS
    explicit DecimalNumPut(bsl::size_t refs = 0);
        // Constructs a 'DecimalNumPut' object.  Optionally specify starting
        // reference count 'refs', which will default to 0.  If 'refs' is
        // non-zero, the 'DecimalNumPut' object will not be deleted when the
        // last locale referencing it goes out of scope.

    // ACCESSORS
    iter_type put(iter_type      out,
                  bsl::ios_base& str,
                  char_type      fill,
                  Decimal32      value) const;
    iter_type put(iter_type      out,
                  bsl::ios_base& str,
                  char_type      fill,
                  Decimal64      value) const;
    iter_type put(iter_type      out,
                  bsl::ios_base& str,
                  char_type      fill,
                  Decimal128     value) const;
        // Forward to, and return using the specified 'out', 'str', 'fill', and
        // 'value', the results of 'this->do_put(out, str, fill, value)'.

  protected:
    // CREATORS
    ~DecimalNumPut();
        // Destroy this object.  Note that the destructor is virtual.

    // ACCESSORS

    virtual iter_type do_put(iter_type      out,
                             bsl::ios_base& ios_format,
                             char_type      fill,
                             Decimal32      value) const;
    virtual iter_type do_put(iter_type      out,
                             bsl::ios_base& ios_format,
                             char_type      fill,
                             Decimal64      value) const;
    virtual iter_type do_put(iter_type      out,
                             bsl::ios_base& ios_format,
                             char_type      fill,
                             Decimal128     value) const;
        // Write characters (of 'char_type') that represent the specified
        // 'value' to the output stream determined by the specified 'out'
        // output iterator.  Use the 'bsl::ctype' and the 'bsl::numpunct'
        // facets imbued to the specified stream-base 'ios_format' as well as
        // the formatting flags of the 'ios_format' ('bsl.flags()') to generate
        // the properly localized output.  The specified 'fill' character will
        // be used as a placeholder character in padded output.  For further,
        // more detailed information please consult the section
        // [lib.facet.num.put.virtuals] of the C++ Standard noting that the
        // length modifiers "H", "D" and "DD" are added to the conversion
        // specifiers of for the types Decimal32, 64 and 128, respectively.
        // Also note that these (possibly overridden) 'do_put' virtual function
        // are used by every formatted C++ stream output operator call
        // ('out << aDecNumber').  Note that currently, only the width,
        // capitalization, justification, fixed and scientific formatting flags
        // are supported, and the operators only support code pages that
        // include the ASCII sub-range.  Because of potential future
        // improvements to support additional formatting flags, the operations
        // should not be used for serialization.

    template <class DECIMAL>
    iter_type do_put_impl(iter_type      out,
                          bsl::ios_base& ios_format,
                          char_type      fill,
                          DECIMAL        value) const;
        // Write characters that represent the specified 'value' into a string
        // of the specified 'char_type', and output the represented decimal
        // number to the specified 'out', adjusting for the formatting flags in
        // the specified 'ios_format' and using the specified 'fill' character.
        // Currently, formatting for the formatting flags of justification,
        // width, uppercase, showpos, fixed and scientific are supported.
};

                   // =====================================
                   // class Decimal_StandardNamespaceCanary
                   // =====================================

class Decimal_StandardNamespaceCanary {
    // An empty class used for error detection when looking for the original
    // name of the standard namespace.  Do not use it.
};

    // =================================================================
    // template<...> class faux_numeric_limits<NUMERIC_TYPE, DUMMY_TYPE>
    // =================================================================

template<class NUMERIC_TYPE, class DUMMY_TYPE = void>
class faux_numeric_limits;
    // This class is used as a base-class for manifest constants in the
    // 'std::numeric_limits' specializations to overcome a Sun compiler issue.

      // ===============================================================
      // class faux_numeric_limits<Decimal_StandardNamespaceCanary, ...>
      // ===============================================================

template<class DUMMY_TYPE>
class faux_numeric_limits<Decimal_StandardNamespaceCanary, DUMMY_TYPE>
{
    // Explicit full specialization of the standard "traits" template
    // 'std::numeric_limits' for the type
    // 'BloombergLP::bdldfp::Decimal_StandardNamespaceCanary'.  Note that this
    // specialization is required for technical reasons and it is identical to
    // the non-specialized default traits.

  public:
    // CLASS DATA
    static const bool is_specialized = false;
        // 'BloombergLP::bdldfp::Decimal_StandardNamespaceCanary' is not a
        // numeric type.
};

    // ==============================================================
    // template<...> class faux_numeric_limits<Decimal32, DUMMY_TYPE>
    // ==============================================================

template<class DUMMY_TYPE>
class faux_numeric_limits<BloombergLP::bdldfp::Decimal32, DUMMY_TYPE> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type 'BloombergLP::bdldfp::Decimal32'.

  public:
    // CLASS DATA
    static const bool is_specialized = true;
        // The template instance
        // 'std::numeric_limits<BloombergLP::bdldfp::Decimal32>' is
        // meaningfully specialized.  Also means that
        // 'BloombergLP::bdldfp::Decimal32' is a numeric type.

    static const int digits = 7;
        // The maximum number of significant digits, in the native (10) radix
        // of the 'BloombergLP::bdldfp::Decimal32' type that the type is able
        // to represent.  Defined to be 7 by IEEE-754.

    static const int digits10 = digits;
        // The maximum number of significant decimal digits that the
        // 'BloombergLP::bdldfp::Decimal32' type is able to represent.  Defined
        // to be 7 by IEEE-754.

    static const int max_digits10 = digits;
        // The number of significant decimal digits necessary to uniquely
        // represent the significant digits of any
        // 'BloombergLP::bdldfp::Decimal32' value.  Note that max_digit10 is
        // the same as digits10 for decimal floating-point values.

    static const bool is_signed = true;
        // 'BloombergLP::bdldfp::Decimal32' is a signed type.

    static const bool is_integer = false;
        // 'BloombergLP::bdldfp::Decimal32' is not an integer type.

    static const bool is_exact = false;
        // 'BloombergLP::bdldfp::Decimal32' is not an exact type, i.e.:
        // calculations done on the type are not free of rounding errors.  Note
        // that integer and possibly rational types may be exact,
        // floating-point types are never exact.

    static const int radix = 10;
        // The base for 'BloombergLP::bdldfp::Decimal32' is decimal or 10.

    static const int min_exponent = -95;
        // The lowest possible negative exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal32' type that does not yet represent a
        // denormal number.  Defined to be -95 by IEEE-754.

    static const int min_exponent10 = min_exponent;
        // The lowest possible negative decimal exponent in the
        // 'BloombergLP::bdldfp::Decimal32' type that does not yet represent a
        // denormal number.  Defined to be -95 by IEEE-754.  Note that
        // 'min_exponent10' is the same as 'min_exponent' for decimal types.

    static const int max_exponent = 96;
        // The highest possible positive exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal32' type that represents a finite
        // value.  Defined to be 96 by IEEE-754.

    static const int max_exponent10 = max_exponent;
        // The highest possible positive decimal exponent of the
        // 'BloombergLP::bdldfp::Decimal32' type that represents a finite
        // value.  Defined to be 97 by IEEE-754.  Note that 'max_exponent10' is
        // the same as 'max_exponent' for decimal types.

    static const bool has_infinity = true;
        // 'BloombergLP::bdldfp::Decimal32' can represent infinity.

    static const bool has_quiet_NaN = true;
        // 'BloombergLP::bdldfp::Decimal32' can be a non-signaling Not a
        // Number.

    static const bool has_signaling_NaN = true;
        // 'BloombergLP::bdldfp::Decimal32' can be a signaling Not a Number.

    static const std::float_denorm_style has_denorm = std::denorm_present;
        // 'BloombergLP::bdldfp::Decimal32' may contain denormal values.

    static const bool has_denorm_loss = true;
        // 'BloombergLP::bdldfp::Decimal32' is able to distinguish loss of
        // precision (floating-point underflow) due to denormalization from
        // other causes.

    static const bool is_bounded = true;
        // Decimal floating-point types represent a finite set of values.

    static const bool is_iec559 = false;
        // Decimal floating-point is not covered by the IEC 559 standard.

    static const bool is_modulo = false;
        // Decimal floating-point types do not have modulo representation.

    static const bool tinyness_before = true;
        // Decimal floating-point types are able to detect if a value is too
        // small to represent as a normalized value before rounding it.

    static const bool traps = true;
        // Decimal floating-point types implement traps to report arithmetic
        // exceptions (required by IEEE-754).

    static const int max_precision = digits10 - 1 + (-min_exponent10);
        // The highest possible precision in the
        // 'BloombergLP::bdldfp::Decimal32' type that is large enough to
        // output the smallest non-zero denormalized value in fixed notation.

                        // Rounding style

    static const std::float_round_style round_style = std::round_indeterminate;
        // Decimal floating-point rounding style is defined to be indeterminate
        // by the C and C++ Decimal TRs.
};

    // ==============================================================
    // template<...> class faux_numeric_limits<Decimal64, DUMMY_TYPE>
    // ==============================================================

template<class DUMMY_TYPE>
class faux_numeric_limits<BloombergLP::bdldfp::Decimal64, DUMMY_TYPE> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type 'BloombergLP::bdldfp::Decimal64'.

  public:
    // CLASS DATA
    static const bool is_specialized = true;
        // The template instance
        // 'std::numeric_limits<BloombergLP::bdldfp::Decimal64>' is
        // meaningfully specialized.  Also means that
        // 'BloombergLP::bdldfp::Decimal64' is a numeric type.

    static const int digits = 16;
        // The maximum number of significant digits, in the native (10) radix
        // of the 'BloombergLP::bdldfp::Decimal64' type that the type is able
        // to represent.  Defined to be 16 by IEEE-754.

    static const int digits10 = digits;
        // The maximum number of significant decimal digits that the
        // 'BloombergLP::bdldfp::Decimal64' type is able to represent.  Defined
        // to be 16 by IEEE-754.

    static const int max_digits10 = digits;
        // The number of significant decimal digits necessary to uniquely
        // represent the significant digits of any
        // 'BloombergLP::bdldfp::Decimal64' value.  Note that max_digit10 is
        // the same as digits10 for decimal floating-point values.

    static const bool is_signed = true;
        // 'BloombergLP::bdldfp::Decimal64' is a signed type.

    static const bool is_integer = false;
        // 'BloombergLP::bdldfp::Decimal64' is not an integer type.

    static const bool is_exact = false;
        // 'BloombergLP::bdldfp::Decimal64' is not an exact type, i.e.:
        // calculations done on the type are not free of rounding errors.  Note
        // that integer and possibly rational types may be exact,
        // floating-point types are never exact.

    static const int radix = 10;
        // The base for 'BloombergLP::bdldfp::Decimal64' is decimal or 10.

    static const int min_exponent = -383;
        // The lowest possible negative exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal64' type that does not yet represent a
        // denormal number.  Defined to be -383 by IEEE-754.

    static const int min_exponent10 = min_exponent;
        // The lowest possible negative decimal exponent in the
        // 'BloombergLP::bdldfp::Decimal64' type that does not yet represent a
        // denormal number.  Defined to be -382 by IEEE-754.  Note that
        // 'min_exponent10' is the same as 'min_exponent' for decimal types.

    static const int max_exponent = 384;
        // The highest possible positive exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal64' type that represents a finite
        // value.  Defined to be 384 by IEEE-754.

    static const int max_exponent10 = max_exponent;
        // The highest possible positive decimal exponent of the
        // 'BloombergLP::bdldfp::Decimal64' type that represents a finite
        // value.  Defined to be 384 by IEEE-754.  Note that 'max_exponent10'
        // is the same as 'max_exponent' for decimal types.

    static const bool has_infinity = true;
        // 'BloombergLP::bdldfp::Decimal64' can represent infinity.

    static const bool has_quiet_NaN = true;
        // 'BloombergLP::bdldfp::Decimal64' can be a non-signaling Not a
        // Number.

    static const bool has_signaling_NaN = true;
        // 'BloombergLP::bdldfp::Decimal64' can be a signaling Not a Number.

    static const std::float_denorm_style has_denorm = std::denorm_present;
        // 'BloombergLP::bdldfp::Decimal64' may contain denormal values.

    static const bool has_denorm_loss = true;
        // 'BloombergLP::bdldfp::Decimal64' is able to distinguish loss of
        // precision (floating-point underflow) due to denormalization from
        // other causes.

    static const bool is_iec559 = false;
        // Decimal floating-point is not covered by the IEC 559 standard.

    static const bool is_bounded = true;
        // Decimal floating-point types represent a finite set of values.

    static const bool is_modulo = false;
        // Decimal floating-point types do not have modulo representation.

    static const bool traps = true;
        // Decimal floating-point types implement traps to report arithmetic
        // exceptions (required by IEEE-754).

    static const bool tinyness_before = true;
        // Decimal floating-point types are able to detect if a value is too
        // small to represent as a normalized value before rounding it.

    static const int max_precision = digits10 - 1 + (-min_exponent10);
        // The highest possible precision in the
        // 'BloombergLP::bdldfp::Decimal64' type that is large enough to
        // output the smallest non-zero denormalized value in fixed notation.

    static const std::float_round_style round_style = std::round_indeterminate;
        // Decimal floating-point rounding style is defined to be indeterminate
        // by the C and C++ Decimal TRs.
};

    // ===============================================================
    // template<...> class faux_numeric_limits<Decimal128, DUMMY_TYPE>
    // ===============================================================

template<class DUMMY_TYPE>
class faux_numeric_limits<BloombergLP::bdldfp::Decimal128, DUMMY_TYPE> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type
        // 'BloombergLP::bdldfp::Decimal128'.

  public:
    // CLASS DATA
    static const bool is_specialized = true;
        // The template instance
        // 'std::numeric_limits<BloombergLP::bdldfp::Decimal128>' is
        // meaningfully specialized.  Also means that
        // 'BloombergLP::bdldfp::Decimal128' is a numeric type.

    static const int digits = 34;
        // The maximum number of significant digits, in the native (10) radix
        // of the 'BloombergLP::bdldfp::Decimal128' type that the type is able
        // to represent.  Defined to be 34 by IEEE-754.

    static const int digits10 = digits;
        // The maximum number of significant decimal digits that the
        // 'BloombergLP::bdldfp::Decimal128' type is able to represent.
        // Defined to be 34 by IEEE-754.

    static const int max_digits10 = digits;
        // The number of significant decimal digits necessary to uniquely
        // represent the significant digits of any
        // 'BloombergLP::bdldfp::Decimal128' value.  Note that max_digit10 is
        // the same as digits10 for decimal floating-point values.

    static const bool is_signed = true;
        // 'BloombergLP::bdldfp::Decimal128' is a signed type.

    static const bool is_integer = false;
        // 'BloombergLP::bdldfp::Decimal128' is not an integer type.

    static const bool is_exact = false;
        // 'BloombergLP::bdldfp::Decimal128' is not an exact type, i.e.:
        // calculations done on the type are not free of rounding errors.  Note
        // that integer and possibly rational types may be exact,
        // floating-point types are never exact.

    static const int radix = 10;
        // The base for 'BloombergLP::bdldfp::Decimal128' is decimal or 10.

    static const int min_exponent = -6143;
        // The lowest possible negative exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal128' type that does not yet represent a
        // denormal number.  Defined to be -6143 by IEEE-754.

    static const int min_exponent10 = min_exponent;
        // The lowest possible negative decimal exponent in the
        // 'BloombergLP::bdldfp::Decimal128' type that does not yet represent a
        // denormal number.  Defined to be -6142 by IEEE-754.  Note that
        // 'min_exponent10' is the same as 'min_exponent' for decimal types.

    static const int max_exponent = 6144;
        // The highest possible positive exponent for the native base of the
        // 'BloombergLP::bdldfp::Decimal128' type that represents a finite
        // value.  Defined to be 385 by IEEE-754.

    static const int max_exponent10 = max_exponent;
        // The highest possible positive decimal exponent of the
        // 'BloombergLP::bdldfp::Decimal128' type that represents a finite
        // value.  Defined to be 6145 by IEEE-754.  Note that 'max_exponent10'
        // is the same as 'max_exponent' for decimal types.

    static const bool has_infinity = true;
        // 'BloombergLP::bdldfp::Decimal128' can represent infinity.

    static const bool has_quiet_NaN = true;
        // 'BloombergLP::bdldfp::Decimal128' can be a non-signaling Not a
        // Number.

    static const bool has_signaling_NaN = true;
        // 'BloombergLP::bdldfp::Decimal128' can be a signaling Not a Number.

    static const std::float_denorm_style has_denorm = std::denorm_present;
        // 'BloombergLP::bdldfp::Decimal128' may contain denormal values.

    static const bool has_denorm_loss = true;
        // 'BloombergLP::bdldfp::Decimal128' is able to distinguish loss of
        // precision (floating-point underflow) due to denormalization from
        // other causes.

    static const bool is_iec559 = false;
        // Decimal floating-point is not covered by the IEC 559 standard.

    static const bool is_bounded = true;
        // Decimal floating-point types represent a finite set of values.

    static const bool is_modulo = false;
        // Decimal floating-point types do not have modulo representation.

    static const bool traps = true;
        // Decimal floating-point types implement traps to report arithmetic
        // exceptions (required by IEEE-754).

    static const bool tinyness_before = true;
        // Decimal floating-point types are able to detect if a value is too
        // small to represent as a normalized value before rounding it.

    static const int max_precision = digits10 - 1 + (-min_exponent10);
        // The highest possible precision in the
        // 'BloombergLP::bdldfp::Decimal128' type that is large enough to
        // output the smallest non-zero denormalized value in fixed notation.

    static const std::float_round_style round_style = std::round_indeterminate;
        // Decimal floating-point rounding style is defined to be indeterminate
        // by the C and C++ Decimal TRs.

};

             // --------------------------------------------------
             // faux_numeric_limits<Decimal32, ...> member storage
             // --------------------------------------------------

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_specialized;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::digits;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::digits10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::max_digits10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_signed;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_integer;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_exact;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::radix;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::min_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::min_exponent10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::max_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal32, DUMMY_TYPE>::max_exponent10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::has_infinity;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::has_quiet_NaN;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::has_signaling_NaN;

template<class DUMMY_TYPE>
const std::float_denorm_style
faux_numeric_limits<Decimal32, DUMMY_TYPE>::has_denorm;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::has_denorm_loss;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_iec559;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_bounded;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::is_modulo;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::traps;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal32, DUMMY_TYPE>::tinyness_before;

template<class DUMMY_TYPE>
const std::float_round_style
faux_numeric_limits<Decimal32, DUMMY_TYPE>::round_style;

             // --------------------------------------------------
             // faux_numeric_limits<Decimal64, ...> member storage
             // --------------------------------------------------

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_specialized;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::digits;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::digits10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::max_digits10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_signed;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_integer;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_exact;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::radix;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::min_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::min_exponent10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::max_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal64, DUMMY_TYPE>::max_exponent10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::has_infinity;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::has_quiet_NaN;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::has_signaling_NaN;

template<class DUMMY_TYPE>
const std::float_denorm_style
faux_numeric_limits<Decimal64, DUMMY_TYPE>::has_denorm;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::has_denorm_loss;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_iec559;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_bounded;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::is_modulo;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::traps;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal64, DUMMY_TYPE>::tinyness_before;

template<class DUMMY_TYPE>
const std::float_round_style
faux_numeric_limits<Decimal64, DUMMY_TYPE>::round_style;

            // ---------------------------------------------------
            // faux_numeric_limits<Decimal128, ...> member storage
            // ---------------------------------------------------

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_specialized;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::digits;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::digits10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::max_digits10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_signed;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_integer;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_exact;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::radix;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::min_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::min_exponent10;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::max_exponent;

template<class DUMMY_TYPE>
const int faux_numeric_limits<Decimal128, DUMMY_TYPE>::max_exponent10;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::has_infinity;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::has_quiet_NaN;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::has_signaling_NaN;

template<class DUMMY_TYPE>
const std::float_denorm_style
faux_numeric_limits<Decimal128, DUMMY_TYPE>::has_denorm;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::has_denorm_loss;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_iec559;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_bounded;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::is_modulo;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::traps;

template<class DUMMY_TYPE>
const bool faux_numeric_limits<Decimal128, DUMMY_TYPE>::tinyness_before;

template<class DUMMY_TYPE>
const std::float_round_style
faux_numeric_limits<Decimal128, DUMMY_TYPE>::round_style;

}  // close package namespace
}  // close enterprise namespace

namespace std {

  // ========================================================================
  // template<> class numeric_limits<bdldfp::Decimal_StandardNamespaceCanary>
  // ========================================================================

template<>
class numeric_limits<BloombergLP::bdldfp::Decimal_StandardNamespaceCanary>
    : public BloombergLP::bdldfp::faux_numeric_limits<
        BloombergLP::bdldfp::Decimal_StandardNamespaceCanary> {
    // Explicit full specialization of the standard "traits" template
    // 'std::numeric_limits' for the type
    // 'BloombergLP::bdldfp::Decimal_StandardNamespaceCanary'.  Note that this
    // specialization is required for technical reasons and it is identical to
    // the non-specialized default traits.
};

             // ==================================================
             // template<> class numeric_limits<bdldfp::Decimal32>
             // ==================================================

template<>
class numeric_limits<BloombergLP::bdldfp::Decimal32>
    : public BloombergLP::bdldfp::faux_numeric_limits<
        BloombergLP::bdldfp::Decimal32> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type 'BloombergLP::bdldfp::Decimal32'.

  public:
    // CLASS METHODS
    static BloombergLP::bdldfp::Decimal32 min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest positive (also non-zero) number
        // 'BloombergLP::bdldfp::Decimal32' can represent (IEEE-754: +1e-95).

    static BloombergLP::bdldfp::Decimal32 max() BSLS_KEYWORD_NOEXCEPT;
        // Return the largest number 'BloombergLP::bdldfp::Decimal32' can
        // represent (IEEE-754: +9.999999e+96).

    static BloombergLP::bdldfp::Decimal32 epsilon() BSLS_KEYWORD_NOEXCEPT;
        // Return the difference between 1 and the smallest value representable
        // by the 'BloombergLP::bdldfp::Decimal32' type.  (IEEE-754: +1e-6)

    static BloombergLP::bdldfp::Decimal32 round_error() BSLS_KEYWORD_NOEXCEPT;
        // Return the maximum rounding error for the
        // 'BloombergLP::bdldfp::Decimal32' type.  The actual value returned
        // depends on the current decimal floating point rounding setting.

    static BloombergLP::bdldfp::Decimal32 denorm_min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest non-zero denormalized value for the
        // 'BloombergLP::bdldfp::Decimal32' type.  (IEEE-754: +0.000001E-95)

    static BloombergLP::bdldfp::Decimal32 infinity() BSLS_KEYWORD_NOEXCEPT;
        // Return the value that represents positive infinity for the
        // 'BloombergLP::bdldfp::Decimal32' type.

    static BloombergLP::bdldfp::Decimal32 quiet_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents non-signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal32' type.

    static
    BloombergLP::bdldfp::Decimal32 signaling_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal32' type.
};

             // ==================================================
             // template<> class numeric_limits<bdldfp::Decimal64>
             // ==================================================

template<>
class numeric_limits<BloombergLP::bdldfp::Decimal64>
    : public BloombergLP::bdldfp::faux_numeric_limits<
        BloombergLP::bdldfp::Decimal64> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type 'BloombergLP::bdldfp::Decimal64'.

  public:
    // CLASS METHODS
    static BloombergLP::bdldfp::Decimal64 min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest positive (also non-zero) number
        // 'BloombergLP::bdldfp::Decimal64' can represent (IEEE-754: +1e-383).

    static BloombergLP::bdldfp::Decimal64 max() BSLS_KEYWORD_NOEXCEPT;
        // Return the largest number 'BloombergLP::bdldfp::Decimal64' can
        // represent (IEEE-754: +9.999999999999999e+384).

    static BloombergLP::bdldfp::Decimal64 epsilon() BSLS_KEYWORD_NOEXCEPT;
        // Return the difference between 1 and the smallest value representable
        // by the 'BloombergLP::bdldfp::Decimal64' type.  (IEEE-754: +1e-15)

    static BloombergLP::bdldfp::Decimal64 round_error() BSLS_KEYWORD_NOEXCEPT;
        // Return the maximum rounding error for the
        // 'BloombergLP::bdldfp::Decimal64' type.  The actual value returned
        // depends on the current decimal floating point rounding setting.

    static BloombergLP::bdldfp::Decimal64 denorm_min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest non-zero denormalized value for the
        // 'BloombergLP::bdldfp::Decimal64' type.  (IEEE-754:
        // +0.000000000000001e-383)

    static BloombergLP::bdldfp::Decimal64 infinity() BSLS_KEYWORD_NOEXCEPT;
        // Return the value that represents positive infinity for the
        // 'BloombergLP::bdldfp::Decimal64' type.

    static BloombergLP::bdldfp::Decimal64 quiet_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents non-signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal64' type.

    static
    BloombergLP::bdldfp::Decimal64 signaling_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal64' type.

};

            // ===================================================
            // template<> class numeric_limits<bdldfp::Decimal128>
            // ===================================================

template<>
class numeric_limits<BloombergLP::bdldfp::Decimal128>
    : public BloombergLP::bdldfp::faux_numeric_limits<
        BloombergLP::bdldfp::Decimal128> {
        // Explicit full specialization of the standard "traits" template
        // 'std::numeric_limits' for the type
        // 'BloombergLP::bdldfp::Decimal128'.

  public:
    // CLASS METHODS
    static BloombergLP::bdldfp::Decimal128 min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest positive (also non-zero) number
        // 'BloombergLP::bdldfp::Decimal128' can represent (IEEE-754:
        // +1e-6143).

    static BloombergLP::bdldfp::Decimal128 max() BSLS_KEYWORD_NOEXCEPT;
        // Return the largest number 'BloombergLP::bdldfp::Decimal128' can
        // represent (IEEE-754: +9.999999999999999999999999999999999e+6144).

    static BloombergLP::bdldfp::Decimal128 epsilon() BSLS_KEYWORD_NOEXCEPT;
        // Return the difference between 1 and the smallest value representable
        // by the 'BloombergLP::bdldfp::Decimal128' type.  (IEEE-754: +1e-33)

    static BloombergLP::bdldfp::Decimal128 round_error() BSLS_KEYWORD_NOEXCEPT;
        // Return the maximum rounding error for the
        // 'BloombergLP::bdldfp::Decimal128' type.  The actual value returned
        // depends on the current decimal floating point rounding setting.

    static BloombergLP::bdldfp::Decimal128 denorm_min() BSLS_KEYWORD_NOEXCEPT;
        // Return the smallest non-zero denormalized value for the
        // 'BloombergLP::bdldfp::Decimal128' type.  (IEEE-754:
        // +0.000000000000000000000000000000001e-6143)

    static BloombergLP::bdldfp::Decimal128 infinity() BSLS_KEYWORD_NOEXCEPT;
        // Return the value that represents positive infinity for the
        // 'BloombergLP::bdldfp::Decimal128' type.

    static BloombergLP::bdldfp::Decimal128 quiet_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents non-signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal128' type.

    static
    BloombergLP::bdldfp::Decimal128 signaling_NaN() BSLS_KEYWORD_NOEXCEPT;
        // Return a value that represents signaling NaN for the
        // 'BloombergLP::bdldfp::Decimal128' type.
};

}  // close namespace std

// ============================================================================
//                            INLINE DEFINITIONS
// ============================================================================

namespace BloombergLP {
namespace bdldfp {

                      // THE DECIMAL FLOATING-POINT TYPES

                            // --------------------
                            // class Decimal_Type32
                            // --------------------

// CLASS METHODS

                                  // Aspects
inline
int Decimal_Type32::maxSupportedBdexVersion()
{
    return 1;
}

inline
int Decimal_Type32::maxSupportedBdexVersion(int /* versionSelector */)
{
    return 1;
}

// CREATORS
inline
Decimal_Type32::Decimal_Type32()
{
    bsl::memset(&d_value, 0, sizeof(d_value));
}

inline
Decimal_Type32::Decimal_Type32(DecimalImpUtil::ValueType32 value)
: d_value(value)
{
}

inline
Decimal_Type32::Decimal_Type32(Decimal_Type64 other)
: d_value(DecimalImpUtil::convertToDecimal32(*other.data()))
{
}

inline
Decimal_Type32::Decimal_Type32(Decimal_Type128 other)
: d_value(DecimalImpUtil::convertToDecimal32(*other.data()))
{
}

inline
Decimal_Type32::Decimal_Type32(float other)
: d_value(DecimalImpUtil::binaryToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(double other)
: d_value(DecimalImpUtil::binaryToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(int other)
: d_value(DecimalImpUtil::int32ToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(unsigned int other)
: d_value(DecimalImpUtil::uint32ToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(long int other)
: d_value(DecimalImpUtil::int64ToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(unsigned long int other)
: d_value(DecimalImpUtil::uint64ToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(long long other)
: d_value(DecimalImpUtil::int64ToDecimal32(other))
{
}

inline
Decimal_Type32::Decimal_Type32(unsigned long long other)
: d_value(DecimalImpUtil::uint64ToDecimal32(other))
{
}

// MANIPULATORS

                     // Incrementation and Decrementation

inline Decimal_Type32& Decimal_Type32::operator++()
{
    return *this += Decimal32(1);
}

inline Decimal_Type32& Decimal_Type32::operator--()
{
    return *this -= Decimal32(1);
}

                                  // Addition

inline Decimal_Type32& Decimal_Type32::operator+=(Decimal32 rhs)
{
    this->d_value = DecimalImpUtil::add(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type32& Decimal_Type32::operator+=(Decimal64 rhs)
{
    return *this = Decimal32(Decimal64(*this) + rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(Decimal128 rhs)
{
    return *this = Decimal32(Decimal128(*this) + rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(int rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(unsigned int rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(long rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(unsigned long rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(long long rhs)
{
    return *this += Decimal128(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator+=(unsigned long long rhs)
{
    return *this += Decimal128(rhs);
}

                                // Subtraction

inline Decimal_Type32& Decimal_Type32::operator-=(Decimal32 rhs)
{
    this->d_value = DecimalImpUtil::subtract(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type32& Decimal_Type32::operator-=(Decimal64 rhs)
{
    return *this = Decimal32(Decimal64(*this) - rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(Decimal128 rhs)
{
    return *this = Decimal32(Decimal128(*this) - rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(int rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(unsigned int rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(long rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(unsigned long rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(long long rhs)
{
    return *this -= Decimal128(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator-=(unsigned long long rhs)
{
    return *this -= Decimal128(rhs);
}

                               // Multiplication

inline Decimal_Type32& Decimal_Type32::operator*=(Decimal32 rhs)
{
    this->d_value = DecimalImpUtil::multiply(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type32& Decimal_Type32::operator*=(Decimal64 rhs)
{
    return *this = Decimal32(Decimal64(*this) * rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(Decimal128 rhs)
{
    return *this = Decimal32(Decimal128(*this) * rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(int rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(unsigned int rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(long rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(unsigned long rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(long long rhs)
{
    return *this *= Decimal128(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator*=(unsigned long long rhs)
{
    return *this *= Decimal128(rhs);
}

                                  // Division

inline Decimal_Type32& Decimal_Type32::operator/=(Decimal32 rhs)
{
    this->d_value = DecimalImpUtil::divide(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type32& Decimal_Type32::operator/=(Decimal64 rhs)
{
    return *this = Decimal32(Decimal64(*this) / rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(Decimal128 rhs)
{
    return *this = Decimal32(Decimal128(*this) / rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(int rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(unsigned int rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(long rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(unsigned long rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(long long rhs)
{
    return *this /= Decimal128(rhs);
}

inline Decimal_Type32& Decimal_Type32::operator/=(unsigned long long rhs)
{
    return *this /= Decimal128(rhs);
}


inline
DecimalImpUtil::ValueType32 *Decimal_Type32::data()
{
    return &d_value;
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type32::bdexStreamIn(STREAM& stream, int version)
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            DecimalStorage::Type32 bidVal;
            stream.getUint32(bidVal);

            if (stream) {
                d_value.d_raw = bidVal;
            }
            else {
                stream.invalidate();
            }
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }
    return stream;
}

inline
const DecimalImpUtil::ValueType32 *Decimal_Type32::data() const
{
    return &d_value;
}

inline
DecimalImpUtil::ValueType32 Decimal_Type32::value() const
{
    return d_value;
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type32::bdexStreamOut(STREAM& stream, int version) const
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            stream.putUint32(d_value.d_raw);
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }
    return stream;
}

                            // --------------------
                            // class Decimal_Type64
                            // --------------------

// CLASS METHODS

                                  // Aspects
inline
int Decimal_Type64::maxSupportedBdexVersion()
{
    return 1;
}

inline
int Decimal_Type64::maxSupportedBdexVersion(int /* versionSelector */)
{
    return 1;
}

// CREATORS
inline
Decimal_Type64::Decimal_Type64()
{
    bsl::memset(&d_value, 0, sizeof(d_value));
}

inline
Decimal_Type64::Decimal_Type64(DecimalImpUtil::ValueType64 value)
: d_value(value)
{
}

inline
Decimal_Type64::Decimal_Type64(Decimal32 other)
: d_value(DecimalImpUtil::convertToDecimal64(*other.data()))
{
}

inline
Decimal_Type64::Decimal_Type64(Decimal128 other)
: d_value(DecimalImpUtil::convertToDecimal64(*other.data()))
{
}

                     // Numerical Conversion Constructors

inline
Decimal_Type64::Decimal_Type64(float other)
: d_value(DecimalImpUtil::binaryToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(double other)
: d_value(DecimalImpUtil::binaryToDecimal64(other))
{
}

                      // Integral Conversion Constructors

inline
Decimal_Type64::Decimal_Type64(int other)
: d_value(DecimalImpUtil::int32ToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(unsigned int other)
: d_value(DecimalImpUtil::uint32ToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(long other)
: d_value(DecimalImpUtil::int64ToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(unsigned long other)
: d_value(DecimalImpUtil::uint64ToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(long long other)
: d_value(DecimalImpUtil::int64ToDecimal64(other))
{
}

inline
Decimal_Type64::Decimal_Type64(unsigned long long other)
: d_value(DecimalImpUtil::uint64ToDecimal64(other))
{
}


// MANIPULATORS

                     // Incrementation and Decrementation

inline Decimal_Type64& Decimal_Type64::operator++()
{
    return *this += Decimal64(1);
}

inline Decimal_Type64& Decimal_Type64::operator--()
{
    return *this -= Decimal64(1);
}

                                  // Addition

inline Decimal_Type64& Decimal_Type64::operator+=(Decimal32 rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(Decimal64 rhs)
{
    this->d_value = DecimalImpUtil::add(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type64& Decimal_Type64::operator+=(Decimal128 rhs)
{
    return *this = Decimal64(Decimal128(*this) + rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(int rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(unsigned int rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(long rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(unsigned long rhs)
{
    return *this += Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(long long rhs)
{
    return *this += Decimal128(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator+=(unsigned long long rhs)
{
    return *this += Decimal128(rhs);
}

                                // Subtraction

inline Decimal_Type64& Decimal_Type64::operator-=(Decimal32 rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(Decimal64 rhs)
{
    this->d_value = DecimalImpUtil::subtract(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type64& Decimal_Type64::operator-=(Decimal128 rhs)
{
    return *this = Decimal64(Decimal128(*this) - rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(int rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(unsigned int rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(long rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(unsigned long rhs)
{
    return *this -= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(long long rhs)
{
    return *this -= Decimal128(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator-=(unsigned long long rhs)
{
    return *this -= Decimal128(rhs);
}

                               // Multiplication

inline Decimal_Type64& Decimal_Type64::operator*=(Decimal32 rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(Decimal64 rhs)
{
    this->d_value = DecimalImpUtil::multiply(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type64& Decimal_Type64::operator*=(Decimal128 rhs)
{
    return *this = Decimal64(Decimal128(*this) * rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(int rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(unsigned int rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(long rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(unsigned long rhs)
{
    return *this *= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(long long rhs)
{
    return *this *= Decimal128(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator*=(unsigned long long rhs)
{
    return *this *= Decimal128(rhs);
}

                                  // Division

inline Decimal_Type64& Decimal_Type64::operator/=(Decimal32 rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(Decimal64 rhs)
{
    this->d_value = DecimalImpUtil::divide(this->d_value, rhs.d_value);
    return *this;
}

inline Decimal_Type64& Decimal_Type64::operator/=(Decimal128 rhs)
{
    return *this = Decimal64(Decimal128(*this) / rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(int rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(unsigned int rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(long rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(unsigned long rhs)
{
    return *this /= Decimal64(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(long long rhs)
{
    return *this /= Decimal128(rhs);
}

inline Decimal_Type64& Decimal_Type64::operator/=(unsigned long long rhs)
{
    return *this /= Decimal128(rhs);
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type64::bdexStreamIn(STREAM& stream, int version)
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            DecimalStorage::Type64 bidVal;
            stream.getUint64(bidVal);

            if (stream) {
                d_value.d_raw = bidVal;
            }
            else {
                stream.invalidate();
            }
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }

    return stream;
}

//ACCESSORS

                            // Internals Accessors

inline DecimalImpUtil::ValueType64 *Decimal_Type64::data()
{
    return &d_value;
}

inline const DecimalImpUtil::ValueType64 *Decimal_Type64::data() const
{
    return &d_value;
}

inline DecimalImpUtil::ValueType64 Decimal_Type64::value() const
{
    return d_value;
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type64::bdexStreamOut(STREAM& stream, int version) const
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            stream.putUint64(d_value.d_raw);
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }
    return stream;
}

                           // ---------------------
                           // class Decimal_Type128
                           // ---------------------

// CLASS METHODS

                                  // Aspects
inline
int Decimal_Type128::maxSupportedBdexVersion()
{
    return 1;
}

inline
int Decimal_Type128::maxSupportedBdexVersion(int /* versionSelector */)
{
    return 1;
}

// CREATORS
inline
Decimal_Type128::Decimal_Type128()
{
    bsl::memset(&d_value, 0, sizeof(d_value));
}

inline
Decimal_Type128::Decimal_Type128(DecimalImpUtil::ValueType128 value)
: d_value(value)
{
}

inline
Decimal_Type128::Decimal_Type128(Decimal32 value)
: d_value(DecimalImpUtil::convertToDecimal128(*value.data()))
{
}

inline
Decimal_Type128::Decimal_Type128(Decimal64 value)
: d_value(DecimalImpUtil::convertToDecimal128(*value.data()))
{
}

inline
Decimal_Type128::Decimal_Type128(float other)
: d_value(DecimalImpUtil::binaryToDecimal128(other))
{
}

inline
Decimal_Type128::Decimal_Type128(double other)
: d_value(DecimalImpUtil::binaryToDecimal128(other))
{
}

inline
Decimal_Type128::Decimal_Type128(int value)
: d_value(DecimalImpUtil::int32ToDecimal128(value))
{
}

inline Decimal_Type128::Decimal_Type128(unsigned int value)
: d_value(DecimalImpUtil::uint32ToDecimal128(value))
{
}

inline Decimal_Type128::Decimal_Type128(long value)
: d_value(DecimalImpUtil::int64ToDecimal128(value))
{
}

inline Decimal_Type128::Decimal_Type128(unsigned long value)
: d_value(DecimalImpUtil::uint64ToDecimal128(value))
{
}

inline Decimal_Type128::Decimal_Type128(long long value)
: d_value(DecimalImpUtil::int64ToDecimal128(value))
{
}

inline Decimal_Type128::Decimal_Type128(unsigned long long value)
: d_value(DecimalImpUtil::uint64ToDecimal128(value))
{
}


inline
Decimal_Type128& Decimal_Type128::operator++()
{
    return *this += Decimal128(1);
}

inline
Decimal_Type128& Decimal_Type128::operator--()
{
    return *this -= Decimal128(1);
}

                                  // Addition

inline
Decimal_Type128& Decimal_Type128::operator+=(Decimal32 rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(Decimal64 rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(Decimal128 rhs)
{
    this->d_value = DecimalImpUtil::add(this->d_value, rhs.d_value);
    return *this;
}

inline
Decimal_Type128& Decimal_Type128::operator+=(int rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(unsigned int rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(long rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(unsigned long rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(long long rhs)
{
    return *this += Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator+=(unsigned long long rhs)
{
    return *this += Decimal128(rhs);
}

                                // Subtraction

inline
Decimal_Type128& Decimal_Type128::operator-=(Decimal32 rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(Decimal64 rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(Decimal128 rhs)
{
    this->d_value = DecimalImpUtil::subtract(this->d_value, rhs.d_value);
    return *this;
}


inline
Decimal_Type128& Decimal_Type128::operator-=(int rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(unsigned int rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(long rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(unsigned long rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(long long rhs)
{
    return *this -= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator-=(unsigned long long rhs)
{
    return *this -= Decimal128(rhs);
}

                               // Multiplication

inline
Decimal_Type128& Decimal_Type128::operator*=(Decimal32 rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(Decimal64 rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(Decimal128 rhs)
{
    this->d_value = DecimalImpUtil::multiply(this->d_value, rhs.d_value);
    return *this;
}


inline
Decimal_Type128& Decimal_Type128::operator*=(int rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(unsigned int rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(long rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(unsigned long rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(long long rhs)
{
    return *this *= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator*=(unsigned long long rhs)
{
    return *this *= Decimal128(rhs);
}

                                  // Division

inline
Decimal_Type128& Decimal_Type128::operator/=(Decimal32 rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(Decimal64 rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(Decimal128 rhs)
{
    this->d_value = DecimalImpUtil::divide(this->d_value, rhs.d_value);
    return *this;
}


inline
Decimal_Type128& Decimal_Type128::operator/=(int rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(unsigned int rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(long rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(unsigned long rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(long long rhs)
{
    return *this /= Decimal128(rhs);
}

inline
Decimal_Type128& Decimal_Type128::operator/=(unsigned long long rhs)
{
    return *this /= Decimal128(rhs);
}

                            // Internals Accessors

inline
DecimalImpUtil::ValueType128 *Decimal_Type128::data()
{
    return &d_value;
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type128::bdexStreamIn(STREAM& stream, int version)
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            DecimalStorage::Type128 bidVal;
            const int len = sizeof(DecimalStorage::Type128)
                            / sizeof(unsigned char);

            unsigned char *value_p =
                                    reinterpret_cast<unsigned char *>(&bidVal);

#ifdef BSLS_PLATFORM_IS_BIG_ENDIAN
            for (int i(0); i < len; ++i) {
                stream.getUint8(*(value_p + i));
            }
#elif defined(BSLS_PLATFORM_IS_LITTLE_ENDIAN)
            for (int i(len - 1); i >= 0; --i) {
                stream.getUint8(*(value_p + i));
            }
#endif
            if (stream) {
                d_value.d_raw = bidVal;
            }
            else {
                stream.invalidate();
            }
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }
    return stream;
}

inline
const DecimalImpUtil::ValueType128 *Decimal_Type128::data() const
{
    return &d_value;
}

inline
DecimalImpUtil::ValueType128 Decimal_Type128::value() const
{
    return d_value;
}

                                  // Aspects

template <class STREAM>
STREAM& Decimal_Type128::bdexStreamOut(STREAM& stream, int version) const
{
    if (stream) {
        switch (version) { // switch on the schema version
          case 1: {
            const int len = sizeof(DecimalStorage::Type128)
                            / sizeof(unsigned char);

            const unsigned char *value_p =
                       reinterpret_cast<const unsigned char *>(&d_value.d_raw);

#ifdef BSLS_PLATFORM_IS_BIG_ENDIAN
            for (int i(0); i < len; ++i) {
                stream.putUint8(*(value_p + i));
            }
#elif defined(BSLS_PLATFORM_IS_LITTLE_ENDIAN)
            for (int i(len - 1); i >= 0; --i) {
                stream.putUint8(*(value_p + i));
            }
#endif
          } break;
          default: {
            stream.invalidate();  // unrecognized version number
          }
        }
    }
    return stream;
}
}  // close package namespace


// FREE OPERATORS

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 value)
{
    return value;
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 value)
{
    return Decimal32(DecimalImpUtil::negate(value.value()));
}

inline
bdldfp::Decimal32 bdldfp::operator++(bdldfp::Decimal32& value, int)
{
    bdldfp::Decimal32 result(value);
    ++value;
    return result;
}

inline
bdldfp::Decimal32 bdldfp::operator--(bdldfp::Decimal32& value, int)
{
    bdldfp::Decimal32 result(value);
    --value;
    return result;
}

                                  // Addition

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::add(*lhs.data(), *rhs.data());
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    int               rhs)
{
    return Decimal32(lhs + Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    unsigned int      rhs)
{
    return Decimal32(lhs + Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    long              rhs)
{
    return Decimal32(lhs + Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    unsigned long     rhs)
{
    return Decimal32(lhs + Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    long long         rhs)
{
    return Decimal32(lhs + Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(bdldfp::Decimal32  lhs,
                                    unsigned long long rhs)
{
    return Decimal32(lhs + Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator+(int               lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) + rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator+(unsigned int      lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) + rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator+(long              lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) + rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator+(unsigned long     lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) + rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator+(long long         lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal128(lhs) + rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator+(unsigned long long lhs,
                                    bdldfp::Decimal32  rhs)
{
    return Decimal32(Decimal128(lhs) + rhs);
}


                                // Subtraction

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::subtract(*lhs.data(), *rhs.data());
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    int               rhs)
{
    return Decimal32(lhs - Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    unsigned int      rhs)
{
    return Decimal32(lhs - Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    long              rhs)
{
    return Decimal32(lhs - Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    unsigned long     rhs)
{
    return Decimal32(lhs - Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    long long         rhs)
{
    return Decimal32(lhs - Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(bdldfp::Decimal32  lhs,
                                    unsigned long long rhs)
{
    return Decimal32(lhs - Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(int               lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) - rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator-(unsigned int      lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) - rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator-(long              lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) - rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator-(unsigned long     lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) - rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator-(long long         lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal128(lhs) - Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator-(unsigned long long lhs,
                                    bdldfp::Decimal32  rhs)
{
    return Decimal32(Decimal128(lhs) - Decimal64(rhs));
}

                               // Multiplication

inline bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                           bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::multiply(*lhs.data(), *rhs.data());
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                    int               rhs)
{
    return Decimal32(lhs * Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                    unsigned int      rhs)
{
    return Decimal32(lhs * Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                    long              rhs)
{
    return Decimal32(lhs * Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                    unsigned long     rhs)
{
    return Decimal32(lhs * Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                    long long         rhs)
{
    return Decimal32(lhs * Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(bdldfp::Decimal32  lhs,
                                    unsigned long long rhs)
{
    return Decimal32(lhs * Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator*(int               lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) * rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator*(unsigned int      lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) * rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator*(long              lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) * rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator*(unsigned long     lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) * rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator*(long long         lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal128(lhs) * rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator*(unsigned long long lhs,
                                    bdldfp::Decimal32  rhs)
{
    return Decimal32(Decimal128(lhs) * rhs);
}

                               // Division

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::divide(*lhs.data(), *rhs.data());
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    int               rhs)
{
    return Decimal32(lhs / Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    unsigned int      rhs)
{
    return Decimal32(lhs / Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    long              rhs)
{
    return Decimal32(lhs / Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    unsigned long     rhs)
{
    return Decimal32(lhs / Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                    long long         rhs)
{
    return Decimal32(lhs / Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(bdldfp::Decimal32  lhs,
                                    unsigned long long rhs)
{
    return Decimal32(lhs / Decimal128(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(int               lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) / rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator/(unsigned int      lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) / rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator/(long              lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) / Decimal64(rhs));
}

inline
bdldfp::Decimal32 bdldfp::operator/(unsigned long     lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal64(lhs) / rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator/(long long         lhs,
                                    bdldfp::Decimal32 rhs)
{
    return Decimal32(Decimal128(lhs) / rhs);
}

inline
bdldfp::Decimal32 bdldfp::operator/(unsigned long long lhs,
                                    bdldfp::Decimal32  rhs)
{
    return Decimal32(Decimal128(lhs) / rhs);
}


inline
bool bdldfp::operator==(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::equal(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator!=(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::notEqual(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator<(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::less(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator<=(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::lessEqual(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator>(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::greater(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator>=(bdldfp::Decimal32 lhs, bdldfp::Decimal32 rhs)
{
    return DecimalImpUtil::greaterEqual(*lhs.data(), *rhs.data());
}

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline
bdldfp::Decimal32 bdldfp::DecimalLiterals::operator "" _d32(const char *str)
{
    return DecimalImpUtil::parse32(str);
}

inline
bdldfp::Decimal32 bdldfp::DecimalLiterals::operator "" _d32(
                                                  const char *str, bsl::size_t)
{
    return DecimalImpUtil::parse32(str);
}
#endif

// FREE OPERATORS
inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 value)
{
    return value;
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 value)
{
    return DecimalImpUtil::negate(*value.data());
}

inline
bdldfp::Decimal64 bdldfp::operator++(bdldfp::Decimal64& value, int)
{
    bdldfp::Decimal64 result(value);
    ++value;
    return result;
}

inline
bdldfp::Decimal64 bdldfp::operator--(bdldfp::Decimal64& value, int)
{
    bdldfp::Decimal64 result(value);
    --value;
    return result;
}

                                  // Addition

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(DecimalImpUtil::add(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal32 lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) + rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    bdldfp::Decimal32 rhs)
{
    return lhs + Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    int               rhs)
{
    return lhs + Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    unsigned int      rhs)
{
    return lhs + Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    long              rhs)
{
    return lhs + Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    unsigned long     rhs)
{
    return lhs + Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64 lhs,
                                    long long         rhs)
{
    return Decimal64(lhs + Decimal128(rhs));
}

inline
bdldfp::Decimal64 bdldfp::operator+(bdldfp::Decimal64  lhs,
                                    unsigned long long rhs)
{
    return Decimal64(lhs + Decimal128(rhs));
}

inline
bdldfp::Decimal64 bdldfp::operator+(int               lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) + rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator+(unsigned int      lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) + rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator+(long              lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) + rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator+(unsigned long     lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) + rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator+(long long         lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(Decimal128(lhs) + rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator+(unsigned long long lhs,
                                    bdldfp::Decimal64  rhs)
{
    return Decimal64(Decimal128(lhs) + rhs);
}

                                // Subtraction

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(DecimalImpUtil::subtract(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal32 lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) - rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    bdldfp::Decimal32 rhs)
{
    return lhs - Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    int               rhs)
{
    return lhs - Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    unsigned int      rhs)
{
    return lhs - Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    long              rhs)
{
    return lhs - Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    unsigned long     rhs)
{
    return lhs - Decimal64(rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64 lhs,
                                    long long         rhs)
{
    return Decimal64(lhs - Decimal128(rhs));
}

inline
bdldfp::Decimal64 bdldfp::operator-(bdldfp::Decimal64  lhs,
                                    unsigned long long rhs)
{
    return Decimal64(lhs - Decimal128(rhs));
}

inline
bdldfp::Decimal64 bdldfp::operator-(int               lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) - rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator-(unsigned int      lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) - rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator-(long              lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) - rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator-(unsigned long     lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) - rhs;
}

inline
bdldfp::Decimal64 bdldfp::operator-(long long         lhs,
                                    bdldfp::Decimal64 rhs)
{
    return Decimal64(Decimal128(lhs) - rhs);
}

inline
bdldfp::Decimal64 bdldfp::operator-(unsigned long long lhs,
                                    bdldfp::Decimal64  rhs)
{
    return Decimal64(Decimal128(lhs) - rhs);
}

                               // Multiplication

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(DecimalImpUtil::multiply(*lhs.data(), *rhs.data()));
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal32 lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) * rhs;
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           bdldfp::Decimal32 rhs)
{
    return lhs * Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           int               rhs)
{
    return lhs * Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           unsigned int      rhs)
{
    return lhs * Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           long              rhs)
{
    return lhs * Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           unsigned long     rhs)
{
    return lhs * Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64 lhs,
                                           long long         rhs)
{
    return Decimal64(lhs * Decimal128(rhs));
}

inline bdldfp::Decimal64 bdldfp::operator*(bdldfp::Decimal64  lhs,
                                           unsigned long long rhs)
{
    return Decimal64(lhs * Decimal128(rhs));
}

inline bdldfp::Decimal64 bdldfp::operator*(int               lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) * rhs;
}

inline bdldfp::Decimal64 bdldfp::operator*(unsigned int      lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) * rhs;
}

inline bdldfp::Decimal64 bdldfp::operator*(long              lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) * rhs;
}

inline bdldfp::Decimal64 bdldfp::operator*(unsigned long     lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) * rhs;
}

inline bdldfp::Decimal64 bdldfp::operator*(long long         lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(Decimal128(lhs) * rhs);
}

inline bdldfp::Decimal64 bdldfp::operator*(unsigned long long lhs,
                                           bdldfp::Decimal64  rhs)
{
    return Decimal64(Decimal128(lhs) * rhs);
}

                                  // Division

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(DecimalImpUtil::divide(*lhs.data(), *rhs.data()));
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal32 lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) / rhs;
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           bdldfp::Decimal32 rhs)
{
    return lhs / Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           int               rhs)
{
    return lhs / Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           unsigned int      rhs)
{
    return lhs / Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           long              rhs)
{
    return lhs / Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           unsigned long     rhs)
{
    return lhs / Decimal64(rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64 lhs,
                                           long long         rhs)
{
    return Decimal64(lhs / Decimal128(rhs));
}

inline bdldfp::Decimal64 bdldfp::operator/(bdldfp::Decimal64  lhs,
                                           unsigned long long rhs)
{
    return Decimal64(lhs / Decimal128(rhs));
}

inline bdldfp::Decimal64 bdldfp::operator/(int               lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) / rhs;
}

inline bdldfp::Decimal64 bdldfp::operator/(unsigned int      lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) / rhs;
}

inline bdldfp::Decimal64 bdldfp::operator/(long              lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) / rhs;
}

inline bdldfp::Decimal64 bdldfp::operator/(unsigned long     lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) / rhs;
}

inline bdldfp::Decimal64 bdldfp::operator/(long long         lhs,
                                           bdldfp::Decimal64 rhs)
{
    return Decimal64(Decimal128(lhs) / rhs);
}

inline bdldfp::Decimal64 bdldfp::operator/(unsigned long long lhs,
                                           bdldfp::Decimal64  rhs)
{
    return Decimal64(Decimal128(lhs) / rhs);
}

                                  // Equality

inline bool bdldfp::operator==(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::equal(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator==(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) == rhs;
}

inline bool bdldfp::operator==(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs == Decimal64(rhs);
}

                                 // Inequality

inline bool bdldfp::operator!=(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::notEqual(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator!=(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) != rhs;
}

inline bool bdldfp::operator!=(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs != Decimal64(rhs);
}

                                 // Less Than

inline bool bdldfp::operator<(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::less(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator<(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) < rhs;
}

inline bool bdldfp::operator<(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs < Decimal64(rhs);
}

                                 // Less Equal

inline bool bdldfp::operator<=(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::lessEqual(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator<=(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) <= rhs;
}

inline bool bdldfp::operator<=(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs <= Decimal64(rhs);
}

                                // Greater Than

inline bool bdldfp::operator>(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::greater(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator>(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) > rhs;
}

inline bool bdldfp::operator>(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs > Decimal64(rhs);
}

                               // Greater Equal

inline bool bdldfp::operator>=(bdldfp::Decimal64 lhs, bdldfp::Decimal64 rhs)
{
    return DecimalImpUtil::greaterEqual(*lhs.data(), *rhs.data());
}

inline bool bdldfp::operator>=(bdldfp::Decimal32 lhs, bdldfp::Decimal64 rhs)
{
    return Decimal64(lhs) >= rhs;
}

inline bool bdldfp::operator>=(bdldfp::Decimal64 lhs, bdldfp::Decimal32 rhs)
{
    return lhs >= Decimal64(rhs);
}

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline
bdldfp::Decimal64 bdldfp::DecimalLiterals::operator "" _d64(const char *str)
{
    return DecimalImpUtil::parse64(str);
}

inline
bdldfp::Decimal64 bdldfp::DecimalLiterals::operator "" _d64(
                                                  const char *str, bsl::size_t)
{
    return DecimalImpUtil::parse64(str);
}
#endif

// FREE OPERATORS

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 value)
{
    return value;
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 value)
{
    return Decimal128(DecimalImpUtil::negate(*value.data()));
}

inline
bdldfp::Decimal128 bdldfp::operator++(bdldfp::Decimal128& value, int)
{
    Decimal128 result = value;
    ++value;
    return result;
}

inline
bdldfp::Decimal128 bdldfp::operator--(bdldfp::Decimal128& value, int)
{
    Decimal128 result = value;
    --value;
    return result;
}

                                  // Addition

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(DecimalImpUtil::add(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal32  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal32  rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal64  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal64  rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     int                rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     unsigned int       rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     long               rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     unsigned long      rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     long long          rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(bdldfp::Decimal128 lhs,
                                     unsigned long long rhs)
{
    return lhs + Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator+(int                lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(unsigned int       lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(long               lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(unsigned long      lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(long long          lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator+(unsigned long long lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) + rhs;
}

                                // Subtraction

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(DecimalImpUtil::subtract(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal32  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal32  rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal64  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal64  rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     int                rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     unsigned int       rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     long               rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     unsigned long      rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     long long          rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(bdldfp::Decimal128 lhs,
                                     unsigned long long rhs)
{
    return lhs - Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator-(int                lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(unsigned int       lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(long               lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(unsigned long      lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(long long          lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator-(unsigned long long lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) - rhs;
}

                               // Multiplication

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(DecimalImpUtil::multiply(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal32  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal32  rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal64  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal64  rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     int                rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     unsigned int       rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     long               rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     unsigned long      rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     long long          rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(bdldfp::Decimal128 lhs,
                                     unsigned long long rhs)
{
    return lhs * Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator*(int                lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(unsigned int       lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(long               lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(unsigned long      lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(long long          lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator*(unsigned long long lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) * rhs;
}

                                  // Division

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(DecimalImpUtil::divide(*lhs.data(), *rhs.data()));
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal32  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal32  rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal64  lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     bdldfp::Decimal64  rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     int                rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     unsigned int       rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     long               rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     unsigned long      rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     long long          rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(bdldfp::Decimal128 lhs,
                                     unsigned long long rhs)
{
    return lhs / Decimal128(rhs);
}

inline
bdldfp::Decimal128 bdldfp::operator/(int                lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(unsigned int       lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(long               lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(unsigned long      lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(long long          lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

inline
bdldfp::Decimal128 bdldfp::operator/(unsigned long long lhs,
                                     bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) / rhs;
}

                                  // Equality

inline
bool bdldfp::operator==(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::equal(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator==(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) == rhs;
}

inline
bool bdldfp::operator==(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs == Decimal128(rhs);
}

inline
bool bdldfp::operator==(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) == rhs;
}

inline
bool bdldfp::operator==(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs == Decimal128(rhs);
}

                                 // Inequality

inline
bool bdldfp::operator!=(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::notEqual(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator!=(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) != rhs;
}

inline
bool bdldfp::operator!=(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs != Decimal128(rhs);
}

inline
bool bdldfp::operator!=(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) != rhs;
}

inline
bool bdldfp::operator!=(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs != Decimal128(rhs);
}

                                 // Less Than

inline
bool bdldfp::operator<(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::less(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator<(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) < rhs;
}

inline
bool bdldfp::operator<(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs < Decimal128(rhs);
}

inline
bool bdldfp::operator<(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) < rhs;
}

inline
bool bdldfp::operator<(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs < Decimal128(rhs);
}

                                 // Less Equal

inline
bool bdldfp::operator<=(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::lessEqual(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator<=(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) <= rhs;
}

inline
bool bdldfp::operator<=(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs <= Decimal128(rhs);
}

inline
bool bdldfp::operator<=(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) <= rhs;
}

inline
bool bdldfp::operator<=(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs <= Decimal128(rhs);
}

                                  // Greater

inline
bool bdldfp::operator>(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::greater(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator>(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) > rhs;
}

inline
bool bdldfp::operator>(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs > Decimal128(rhs);
}

inline
bool bdldfp::operator>(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) > rhs;
}

inline
bool bdldfp::operator>(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs > Decimal128(rhs);
}

                               // Greater Equal

inline
bool bdldfp::operator>=(bdldfp::Decimal128 lhs, bdldfp::Decimal128 rhs)
{
    return DecimalImpUtil::greaterEqual(*lhs.data(), *rhs.data());
}

inline
bool bdldfp::operator>=(bdldfp::Decimal32 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) >= rhs;
}

inline
bool bdldfp::operator>=(bdldfp::Decimal128 lhs, bdldfp::Decimal32 rhs)
{
    return lhs >= Decimal128(rhs);
}

inline
bool bdldfp::operator>=(bdldfp::Decimal64 lhs, bdldfp::Decimal128 rhs)
{
    return Decimal128(lhs) >= rhs;
}

inline
bool bdldfp::operator>=(bdldfp::Decimal128 lhs, bdldfp::Decimal64 rhs)
{
    return lhs >= Decimal128(rhs);
}

#if defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_NAMESPACE)  && \
    defined(BSLS_COMPILERFEATURES_SUPPORT_USER_DEFINED_LITERALS)
inline
bdldfp::Decimal128 bdldfp::DecimalLiterals::operator "" _d128(const char *str)
{
    return DecimalImpUtil::parse128(str);
}

inline
bdldfp::Decimal128 bdldfp::DecimalLiterals::operator "" _d128(
                                                  const char *str, bsl::size_t)
{
    return DecimalImpUtil::parse128(str);
}
#endif

// FREE FUNCTIONS
template <class HASHALG>
inline
void bdldfp::hashAppend(HASHALG& hashAlg, const bdldfp::Decimal32& object)
{
    using ::BloombergLP::bslh::hashAppend;

    bdldfp::Decimal32 normalizedObject = DecimalImpUtil::normalize(
                                                               object.value());
    hashAlg(&normalizedObject, sizeof(normalizedObject));
}

template <class HASHALG>
inline
void bdldfp::hashAppend(HASHALG& hashAlg, const bdldfp::Decimal64& object)
{
    using ::BloombergLP::bslh::hashAppend;

    bdldfp::Decimal64 normalizedObject = DecimalImpUtil::normalize(
                                                               object.value());

    hashAlg(&normalizedObject, sizeof(normalizedObject));
}

template <class HASHALG>
inline
void bdldfp::hashAppend(HASHALG& hashAlg, const bdldfp::Decimal128& object)
{
    using ::BloombergLP::bslh::hashAppend;

    bdldfp::Decimal128 normalizedObject = DecimalImpUtil::normalize(
                                                               object.value());

    hashAlg(&normalizedObject, sizeof(normalizedObject));
}

}  // close enterprise namespace

#endif

// ----------------------------------------------------------------------------
// Copyright 2014 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------