Decimal number. This is immutable, like any Haskell value you would ordinarily work with. (Actually, that is a bit of a lie. Under the covers it is a pointer to a C struct, which is in fact mutable like anything in C. However, no function exposed in this API mutates a Quad's pointee after the Quad is created.)

As indicated in the General Decimal Arithmetic specification, a Quad might be a finite number (perhaps the most common type) or it might be infinite or a not-a-number. decClass will tell you a little more about a particular Quad.

A container for multiple Flag indicating which are set and which are not.

Is this Flag set?

A Flags with no Flag set.

Gives a list of strings, one for each flag that is set.

The Env monad

Since Deka is a binding to a C library, all the work happens in the mutable land of C pointers. That means that everything happens in the IO monad. The Env monad is simply a wrapper of the IO monad. Since the Env data constructor is not exported, you can't do arbitrary IO computations in the monad; you can only do the computations from this module. Because all the computations in this module do not create observable side effects, it is safe to use unsafePerformIO to perform Env computations in a pure function. This module does not have such a function so that this module can stay Safe for Safe Haskell purposes; however, the Data.Deka.Pure module does have such a function.

The Ctx monad

The General Decimal Arithmetic specification states that most computations occur within a context, which affects the manner in which computations are done (for instance, the context determines the rounding algorithm). The context also carries some results from computations (for instance, a computation might set a flag to indicate that the result is rounded or inexact or was a division by zero.) The Ctx monad carries this context.

Conceptually the Ctx monad includes the Env monad. Any Env computation can be lifted into a Ctx computation with a liftEnv. You will do most computations in the Ctx monad; however, on occasion it is useful to do computations entirely in the Env monad. You know that computations entirely in the Env monad are unaffected by, and cannot affect, the context.

The Ctx monad captures both the context and the IO. Because Quad is exposed only as an immutable type, and because there is no way to do arbitrary IO in the Ctx monad (which is why it is not an instance of the MonadIO class), it is safe to put an unsafePerformIO on Ctx computations so they can be done in pure functions.

The current status flags, which indicate results from previous computations.

Set the current status to whatever you wish.

The current rounding method

Change the current rounding method

By default, rounding is half even. No status flags are set initially. Returns the final status flags along with the result of the computation.

Lifts an Env computation into a Ctx.

Different categories of Quad.

More information about a particular Quad.

A single decimal digit.

The most significant digit is at the head of the list.

The most significant digit is at the head of the list. Sign of number is not relevant.

A list of digits, less than or equal to coefficientLen long. Corresponds only to finite numbers.

A list of digits, less than or equal to payloadDigitsLen long.

The signed integer which indicates the power of ten by which the coefficient is multiplied.

The minimum and maximum possible exponent. If the coefficient has c digits, and Emax is x, the exponent e is within the closed-ended range

-x - (c - 1) + 1 and x - (c - 1)

See Decimal Arithmetic Specification version 1.70, page 10.

An adjusted exponent is the value of an exponent of a number when that number is expressed as though in scientific notation with one digit before any decimal point. This is the finite exponent + (number of significant digits - 1).

The smallest possible adjusted exponent that is still normal. Adjusted exponents smaller than this are subnormal.

Like minNormal, but returns the size of the regular exponent rather than the adjusted exponent.

For a particular coefficient, the exponent must be in a particular range; coeffExp ensures this relationship is enforced.

Ensures the exponent falls within the correct range.

Encodes a new Quad. The result is always canonical. However, the function does not signal if the result is an sNaN.

Reads a ByteString, which can be in scientific, engineering, or "regular" decimal notation. Also reads NaN, Infinity, etc. Will return a signaling NaN and set the Invalid flag if the string given is invalid.

In the decNumber C library, this function was called fromString; the name was changed here because it doesn't take a regular Haskell String.

Converts a Quad to a string. May use non-scientific notation, but only if that's unambiguous; otherwise, uses scientific notation.

In the decNumber C library, this is called toString; the name was changed here because this function doesn't return a Haskell String.

Returns a string in engineering notation.

In the decNumber C library, this is called toEngString; the name is changed here because the function does not return a regular Haskell String.

fused multiply add.

quantize x y returns z which is x set to have the same quantum as y; that is, numerically the same value but rounded or padded if necessary to have the same exponent as y. Useful for rounding monetary quantities.

Compares two Quad numerically. The result might be -1, 0, 1, or NaN, where -1 means x is less than y, 0 indicates numerical equality, 1 means y is greater than x. NaN is returned only if x or y is an NaN.

Thus, this function does not return an Ordering because the result might be an NaN.

Same as compare, but a quietNaN is treated like a signaling NaN (sets invalidOperation).

Compares using an IEEE 754 total ordering, which takes into account the exponent. IEEE 754 says that this function might return different results depending upon whether the operands are canonical; Quad are always canonical so you don't need to worry about that here.

Same as compareTotal but compares the absolute value of the two arguments.

True if x is finite and has exponent of 0; False otherwise. This can lead to unexpected results; for instance, 3 x 10 ^ 2 is 300, but this function will return False.

True only if x is zero or positive, an integer (finite with exponent of 0), and the coefficient is only zeroes and/or ones.

True only if x is less than zero and is not an NaN.

True only if x is finite, non-zero, and not subnormal.

True only if x is greater than zero and is not an NaN.

True only if x is a signaling NaN.

True only if x has a sign of 1. Note that zeroes and NaNs may have sign of 1.

True only if x is subnormal - that is, finite, non-zero, and with a magnitude less than 10 ^ emin.

True only if x is a zero.

Same effect as 0 + x where the exponent of the zero is the same as that of x if x is finite). NaNs are handled as for arithmetic operations.

Absolute value. NaNs are handled normally (the sign of an NaN is not affected, and an sNaN sets invalidOperation.

copySign x y returns z, which is a copy of x but has the sign of y. Unlike decQuadCopySign, the result is always canonical. This function never raises any signals.

Digit-wise logical and. Operands must be:

• zero or positive * integers * comprise only zeroes and/or ones

If not, invalidOperation is set.

Digit wise logical inclusive Or. Operands must be:

• zero or positive * integers * comprise only zeroes and/or ones

If not, invalidOperation is set.

True only if x is zero or positive, an integer (finite with exponent of 0), and the coefficient is only zeroes and/or ones. The sign must be Sign0 (that is, you cannot have a negative zero.)

True only if x is less than zero and is not an NaN. It's not enough for the sign to be Sign1; the coefficient (if finite) must be greater than zero.

True for any zero (negative or positive zero).

The number of significant digits. Zero returns 1.