XJ=1      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred Safe-Inferred  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ~|}z{xvytwrupsnqlomjkhfidgbe`ca^\_Z]X[VYTWRUPSNQOMLJHKFIGEDB@CA><?=;:869472503.1,/*-(+&)$'"% #!  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None5Decimal number. As indicated in the General Decimal  Arithmetic specification, a  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 . 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 H the flags that computations can set (for instance, a computation might A set a flag to indicate that the result is rounded or inexact or > was a division by zero.) The Ctx monad carries this context.  Converts a & 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  . The Show instance uses .    Trustworthy=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 0 exponent + (number of significant digits - 1). (A list of digits, less than or equal to  8 long. Accompanies an NaN, potentially with diagnostic ? information (I do not know if decNumber actually makes use of  this.) (A list of digits, less than or equal to  long. % Corresponds only to finite numbers. A single decimal digit. >A pure Haskell type which holds information identical to that  in a . =The signed integer which indicates the power of ten by which  the coefficient is multiplied. !,The number is negative or the negative zero ""The number is positive or is zero #A Quad is not a member of  or  because the semantics  of the T2 function do not easily allow for this. However, B if you want to compare using a total ordering, you can wrap your   in #-. For more on what a total ordering is, see  ,http://speleotrove.com/decimal/decifaq4.html and look under Which is larger? 7.5 or 7.500? . As this . title suggests, when using a total ordering, 7.5 and 7.500  are not equal. &Different categories of . 'A container for multiple ( indicating which are set and  which are not. An instance of  so you can throw it if / you want (no functions in this module throw.) (;A single error or warning condition that may be set in the  . * Round toward positive infinity. +Round away from zero. ,0.5 rounds up -0.5 rounds to nearest even .0.5 rounds down /Round toward zero - truncate 0 Round toward negative infinity. 1Round for reround 20/0; is undefined. It sets this flag and returns a quiet NaN. 30A non-zero dividend is divided by zero. Unlike 0/0 , it has a % defined result (a signed Infinity). 4Sometimes raised by \ and |. 5>Raised on a variety of invalid operations, such as an attempt  to use V on an operand that is an NaN. 6>One or more non-zero coefficient digits were discarded during  rounding. 7(A result is both subnormal and inexact. 89The exponent of a result is too large to be represented. 9"A source string (for instance, in _ ) contained  errors. =Is this ( set? >A ' with no ( set. ??The current status flags, which indicate results from previous  computations. @-Set the current status to whatever you wish. BThe current rounding method C#Change the current rounding method DBy default, rounding is set to -. No status flags are set B initially. Returns the final status flags along with the result  of the computation. ELike D& but does not return the final flags. FSignaling NaN G Quiet NaN HNegative infinity INegative normal number JNegative subnormal number KThe negative zero LThe positive zero MA positive subnormal number NA positive normal number OPositive infinity *Creates a new Quad. Uninitialized, so don't export this  function. P?Absolute value. NaNs are handled normally (the sign of an NaN # is not affected, and an sNaN sets 5. R+Digit-wise logical and. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 5 is set. S$More information about a particular . T Compares two # 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  because the  result might be an NaN. U Wrapper for T that returns an  rather than a   . Returns Just LT rather than -1, Just EQ rather than  0, and Just GT rather than 1, and Nothing rather than NaN. 1 This is a pure function; it does not affect the . VSame as T-, but a quietNaN is treated like a signaling  NaN (sets 5). W<Compares using an IEEE 754 total ordering, which takes into ? account the exponent. IEEE 754 says that this function might B return different results depending upon whether the operands are  canonical;  are always canonical so you don't need to worry  about that here. XSame as W( but compares the absolute value of the  two arguments. Y copySign x y returns z, which is a copy of x but has the  sign of y+. This function never raises any signals. Z?Number of significant digits. If zero or infinite, returns 1. 2 If NaN, returns number of digits in the payload. \divideInteger x y( returns the integer part of the result B (rounded toward zero), with an exponent of 0. If the the result / would not fit because it has too many digits,  4 is set. ]Fused multiply add;  fma x y z calculates  x * y + z. The ? multiply is carried out first and is exact, so the result has  only one final rounding. _@Reads a ByteString, which can be in scientific, engineering, or  "regular"3 decimal notation. Also reads NaN, Infinity, etc. % Will return a signaling NaN and set 5 if the  string given is invalid. 5In the decNumber C library, this function was called   fromString,; the name was changed here because it doesn' t take a  regular Haskell . a4Digit-wise logical inversion. The operand must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 5 is set. bTrue if x is neither infinite nor a NaN. cTrue for infinities. dTrue if x is finite and has exponent of 0; False otherwise. " This tests the exponent, not the adjusted exponent. This can % lead to results you may not expect: 6isInteger . evalCtx . fromByteString . pack $ "3.00e2"True3isInteger . evalCtx . fromByteString . pack $ "3e2"False6isInteger . evalCtx . fromByteString . pack $ "3.00e0"Falsee True only if x. is zero or positive, an integer (finite with 7 exponent of 0), and the coefficient is only zeroes and/ or ones. fTrue for NaNs. g True only if x& is less than zero and is not an NaN. h True only if x) is finite, non-zero, and not subnormal. i True only if x) is greater than zero and is not an NaN. j True only if x is a signaling NaN. k True only if x- has a sign of 1. Note that zeroes and NaNs  may have sign of 1. l True only if x/ is subnormal - that is, finite, non-zero, and ' with a magnitude less than 10 ^ emin. m True only if x is a zero. nlogB x7 Returns the adjusted exponent of x, according to IEEE  754 rules. If x% is infinite, returns +Infinity. If x is $ zero, the result is -Infinity, and 3 is set. If  x* is less than zero, the absolute value of x is used. If x A is one, the result is 0. NaNs are propagated as for arithmetic  operations. omax x y7 returns the larger argument; if either (but not both)  x or y7 is a quiet NaN then the other argument is the result; < otherwise, NaNs, are handled as for arithmetic operations. pLike o4 but the absolute values of the arguments are used. qmin x y8 returns the smaller argument; if either (but not both)  x or y7 is a quiet NaN then the other argument is the result; < otherwise, NaNs, are handled as for arithmetic operations. rLike q4 but the absolute values of the arguments are used. s)Negation. Result has the same effect as 0 - x when the - exponent of the zero is the same as that of x, if x is  finite. u%Decrements toward negative infinity. v%Increments toward positive infinity. wnextToward x y returns the next  in the direction of  y. x4Digit wise logical inclusive Or. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 5 is set. ySame 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. z quantize x y returns z which is x set to have the same  quantum as y2; that is, numerically the same value but rounded 5 or padded if necessary to have the same exponent as y . Useful # for rounding monetary quantities. {:Reduces coefficient to its shortest possible form without ; changing the value of the result by removing all possible  trailing zeroes. |>Remainder from integer division. If the intermediate integer  does not fit within a Quad, 4 is raised. }Like |- but the nearest integer is used for for the 0 intermediate result instead of the result from \. ~ rotate x y) rotates the digits of x to the left (if y is  positive) or right (if y$ is negative) without adjusting the  exponent or sign of x. y is the number of positions to ! rotate and must be in the range negate  to   coefficentLen. 7NaNs are propagated as usual. No status is set unless y is " invalid or an operand is an NaN. >True only if both operands have the same exponent or are both - NaNs (quiet or signaling) or both infinite.  scaleB x y calculates  x * 10 ^ y. y must be an integer ; (finite with exponent of 0) in the range of plus or minus 2 *   + ), typically resulting from  n9. Underflow and overflow might occur; NaNs propagate as  usual.  shift x y/ shifts digits the digits of x to the left (if y  is positive) or right (if y$ is negative) without adjusting the  exponent or sign of x*. Any digits shifted in from the left or  right will be 0. y7 is a count of positions to shift; it must be a finite  integer in the range negate  to   . NaNs propagate as usual. If x is infinite ? the result is an infinity of the same sign. No status is set / unless y is invalid or the operand is an NaN. *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 . :Uses the rounding method given rather than the one in the  ;. If the operand is infinite, an NaN, or if the result of $ rounding is outside the range of a , then  5 is set. 6 is not set even if rounding  occurred. Like . but if rounding removes non-zero digits then  6 is set. 9Rounds to an integral using the rounding mode set in the . = If the operand is infinite, an infinity of the same sign is @ returned. If the operand is an NaN, the result is the same as @ for other arithmetic operations. If rounding removes non-zero  digits then 6 is set. toIntegralValue r x returns an integral value of x using  the rounding mode r& rather than the one specified in the . ? If the operand is an NaN, the result is the same as for other  arithmetic operations. 6 is not set even if rounding  occurred.  toUInt32 r x returns the value of x, rounded to an integer & if necessary using the rounding mode r rather than the one  given in the . If x& is infinite, or outside of the range  of a , then 5 is set. 6 is " not set even if rounding occurs. ;The negative zero converts to 0 and is valid, but negative  numbers are not valid. Same as . but if rounding removes non-zero digits then  6 is set. 3Identifies the version of the decNumber C library. 4Digit-wise logical exclusive or. Operands must be:  zero or positive  integers  comprise only zeroes and/or ones If not, 5 is set. 8A Quad whose coefficient, exponent, and sign are all 0. A Quad with coefficient , exponent 0, and sign ". +The minimum and maximum possible exponent. >The smallest possible adjusted exponent that is still normal. 5 Adjusted exponents smaller than this are subnormal. Like /, but returns the size of the regular exponent $ rather than the adjusted exponent. 9Ensures that the exponent is within the range allowed by  . An Exponent whose value is 0.  Decodes a . to a pure Haskell type which holds identical  information. Encodes a new . 3Converts a Decoded to scientific notation. Unlike  0 this will always use scientific notation. For ; NaNs and infinities, the notation is identical to that of B decNumber (see Decimal Arithmetic Specification page 19). This  means that a quiet NaN is NaN while a signaling NaN is sNaN,  and infinity is Infinity. BLike decQuadToString, the payload of an NaN is not shown if it is  zero. =Converts Decoded to ordinary decimal notation. For NaNs and 2 infinities, the notation is identical to that of .  Unlike 1, though the result can always be converted back  to a  using _, the number of significant + digits might change. For example, though 1.2E3 has two  significant digits, using ordinary on this value and then  reading it back in with fromByteString will give you 1200E0, $ which has four significant digits. :Converts a Decoded to a Rational. Returns Nothing if the  Decoded is not finite.  Creates a '. Checks to ensure it is not null and  that it is not longer than  and that it does not + have leading zeroes (if it is 0, a single  is allowed). Coefficient of  Coefficient of   Creates a (. Checks to ensure it is not null, not  longer than * and that it does not have leading zeroes  (if it is 0, a single  is allowed). Payload of [D0] 7The most significant digit is at the head of the list. !The most significant digit is at 8 the head of the list. Sign of number is not relevant. +Maximum number of digits in a coefficient. 'Maximum number of digits in a payload.  True only if x. is zero or positive, an integer (finite with 7 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 C enough for the sign to be Sign1; the coefficient (if finite) must  be greater than zero. /True for any zero (negative or positive zero). 2The number of significant digits. Zero returns 1. @Show gives you a comma-separated list of flags that are set, or & an empty string if no flags are set.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9Sign. Zero if sign is zero; non-zero if sign is not zero  (that is, is negavite.)  Exponent  Coefficient       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#$%)*+,-./01(23456789':;<=>?@ABCDE&FGHIJKLMNOS_^`Qt][\|}z{TUVWXopqrbcdefghijklmysPYuvwRxa~nZ      "!       "!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe  Decimals with a total ordering.  Deka wraps a . Only finite  may become a ; * no infinities or NaN values are allowed.  is a member of  and , making it easy to use for > elementary arithmetic. Any time you perform arithmetic, the @ results are always exact. The arithmetic functions will throw 4 exceptions rather than give you an inexact result.  is not a member  because it is generally A impossible to perform division without getting inexact results,  and  never holds inexact results. @Thrown by arithmetic functions in the Num class, as this is the  only way to indicate errors. <A computation set flags. This will happen if, for example, 6 you calculate a result that is out of range, such as maxBound + maxBound :: Deka7Could not convert an integer to a Deka; it is too big. )Convert any integral to a Deka. Returns   if the 4 integer is too big to fit into a Deka (34 digits). :Convert a string to a Deka. You can use ordinary numeric  strings, such as 3.25 , or exponential notation, like 325E-2. ) More infomration on your choices is at:  4http://speleotrove.com/decimal/daconvs.html#reftonum AYou cannot use strings that represent an NaN or an infinity. If @ you do that, or use an otherwise invalid string, this function  returns  . 9Change a Quad to a Deka. Only succeeds for finite Quad.  "Ord compares by a total ordering.  !Eq compares by a total ordering.   Many of the  functions will throw  if their @ arguments are out of range or if they produce results that are 1 out of range or inexact. For functions that don't throw, you can  use  rather than  , or you can use  Data.Deka.Quad instead of . &Ord compares by value. For instance, compare 3.5 3.500 ==  EQ. %Eq compares by value. For instance,  3.5 == 3.500.          Safe-Inferred       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  ()*+      deka-0.2.0.2Data.Deka.DecnumberData.Deka.Quad Data.DekaData.Deka.Docs.ExamplesData.Deka.DocsData.Deka.Internal C'decQuadc'decQuad'bytesc'decQuad'shortsc'decQuad'words C'decClass C'decContextc'decContext'digitsc'decContext'emaxc'decContext'eminc'decContext'roundc'decContext'trapsc'decContext'statusc'decContext'clamp C'uint64_t C'uint32_t C'uint16_t C'uint8_t C'int32_t C'roundingunsafe'p'decQuadVersionunsafe'c'decQuadVersionunsafe'p'decQuadSameQuantumunsafe'c'decQuadSameQuantumunsafe'p'decQuadRadixunsafe'c'decQuadRadixunsafe'p'decQuadIsZerounsafe'c'decQuadIsZerounsafe'p'decQuadIsSubnormalunsafe'c'decQuadIsSubnormalunsafe'p'decQuadIsSignedunsafe'c'decQuadIsSignedunsafe'p'decQuadIsSignalingunsafe'c'decQuadIsSignalingunsafe'p'decQuadIsPositiveunsafe'c'decQuadIsPositiveunsafe'p'decQuadIsNormalunsafe'c'decQuadIsNormalunsafe'p'decQuadIsNegativeunsafe'c'decQuadIsNegativeunsafe'p'decQuadIsNaNunsafe'c'decQuadIsNaNunsafe'p'decQuadIsInfiniteunsafe'c'decQuadIsInfiniteunsafe'p'decQuadIsLogicalunsafe'c'decQuadIsLogicalunsafe'p'decQuadIsIntegerunsafe'c'decQuadIsIntegerunsafe'p'decQuadIsFiniteunsafe'c'decQuadIsFiniteunsafe'p'decQuadIsCanonicalunsafe'c'decQuadIsCanonicalunsafe'p'decQuadDigitsunsafe'c'decQuadDigitsunsafe'p'decQuadClassStringunsafe'c'decQuadClassStringunsafe'p'decQuadClassunsafe'c'decQuadClassunsafe'p'decQuadCopyunsafe'c'decQuadCopyunsafe'p'decQuadCopySignunsafe'c'decQuadCopySignunsafe'p'decQuadCopyNegateunsafe'c'decQuadCopyNegateunsafe'p'decQuadCopyAbsunsafe'c'decQuadCopyAbsunsafe'p'decQuadCanonicalunsafe'c'decQuadCanonicalunsafe'p'decQuadCompareTotalMagunsafe'c'decQuadCompareTotalMagunsafe'p'decQuadCompareTotalunsafe'c'decQuadCompareTotalunsafe'p'decQuadCompareSignalunsafe'c'decQuadCompareSignalunsafe'p'decQuadCompareunsafe'c'decQuadCompareunsafe'p'decQuadXorunsafe'c'decQuadXorunsafe'p'decQuadToIntegralExactunsafe'c'decQuadToIntegralExactunsafe'p'decQuadToIntegralValueunsafe'c'decQuadToIntegralValueunsafe'p'decQuadToBCDunsafe'c'decQuadToBCDunsafe'p'decQuadSubtractunsafe'c'decQuadSubtractunsafe'p'decQuadShiftunsafe'c'decQuadShiftunsafe'p'decQuadScaleBunsafe'c'decQuadScaleBunsafe'p'decQuadRotateunsafe'c'decQuadRotateunsafe'p'decQuadRemainderNearunsafe'c'decQuadRemainderNearunsafe'p'decQuadRemainderunsafe'c'decQuadRemainderunsafe'p'decQuadReduceunsafe'c'decQuadReduceunsafe'p'decQuadQuantizeunsafe'c'decQuadQuantizeunsafe'p'decQuadPlusunsafe'c'decQuadPlusunsafe'p'decQuadOrunsafe'c'decQuadOrunsafe'p'decQuadNextTowardunsafe'c'decQuadNextTowardunsafe'p'decQuadNextPlusunsafe'c'decQuadNextPlusunsafe'p'decQuadNextMinusunsafe'c'decQuadNextMinusunsafe'p'decQuadMultiplyunsafe'c'decQuadMultiplyunsafe'p'decQuadMinusunsafe'c'decQuadMinusunsafe'p'decQuadMinMagunsafe'c'decQuadMinMagunsafe'p'decQuadMinunsafe'c'decQuadMinunsafe'p'decQuadMaxMagunsafe'c'decQuadMaxMagunsafe'p'decQuadMaxunsafe'c'decQuadMaxunsafe'p'decQuadLogBunsafe'c'decQuadLogBunsafe'p'decQuadInvertunsafe'c'decQuadInvertunsafe'p'decQuadFromBCDunsafe'c'decQuadFromBCDunsafe'p'decQuadFMAunsafe'c'decQuadFMAunsafe'p'decQuadDivideIntegerunsafe'c'decQuadDivideIntegerunsafe'p'decQuadDivideunsafe'c'decQuadDivideunsafe'p'decQuadAndunsafe'c'decQuadAndunsafe'p'decQuadAddunsafe'c'decQuadAddunsafe'p'decQuadAbsunsafe'c'decQuadAbsunsafe'p'decQuadZerounsafe'c'decQuadZerounsafe'p'decQuadToUInt32Exactunsafe'c'decQuadToUInt32Exactunsafe'p'decQuadToUInt32unsafe'c'decQuadToUInt32unsafe'p'decQuadToStringunsafe'c'decQuadToStringunsafe'p'decQuadToEngStringunsafe'c'decQuadToEngStringunsafe'p'decQuadShowunsafe'c'decQuadShowunsafe'p'decQuadSetExponentunsafe'c'decQuadSetExponentunsafe'p'decQuadSetCoefficientunsafe'c'decQuadSetCoefficientunsafe'p'decQuadGetExponentunsafe'c'decQuadGetExponentunsafe'p'decQuadGetCoefficientunsafe'c'decQuadGetCoefficientunsafe'p'decQuadFromStringunsafe'c'decQuadFromStringunsafe'p'decQuadFromUInt32unsafe'c'decQuadFromUInt32!unsafe'p'decQuadFromPackedChecked!unsafe'c'decQuadFromPackedCheckedunsafe'p'decQuadFromPackedunsafe'c'decQuadFromPackedunsafe'p'decQuadFromInt32unsafe'c'decQuadFromInt32unsafe'p'decQuadToInt32Exactunsafe'c'decQuadToInt32Exactunsafe'p'decQuadToInt32unsafe'c'decQuadToInt32unsafe'p'decContextDefaultunsafe'c'decContextDefaultc'NULLc'DEC_ROUND_CEILINGc'DEC_ROUND_UPc'DEC_ROUND_HALF_UPc'DEC_ROUND_HALF_EVENc'DEC_ROUND_HALF_DOWNc'DEC_ROUND_DOWNc'DEC_ROUND_FLOORc'DEC_ROUND_05UPc'DEC_ROUND_MAXp'decContext'digitsp'decContext'emaxp'decContext'eminp'decContext'roundp'decContext'trapsp'decContext'statusp'decContext'clampc'DEC_INIT_DECQUADc'DEC_CLASS_SNANc'DEC_CLASS_QNANc'DEC_CLASS_NEG_INFc'DEC_CLASS_NEG_NORMALc'DEC_CLASS_NEG_SUBNORMALc'DEC_CLASS_NEG_ZEROc'DEC_CLASS_POS_ZEROc'DEC_CLASS_POS_SUBNORMALc'DEC_CLASS_POS_NORMALc'DEC_CLASS_POS_INFc'DEC_Conversion_syntaxc'DEC_Division_by_zeroc'DEC_Division_impossiblec'DEC_Division_undefinedc'DEC_Insufficient_storage c'DEC_Inexactc'DEC_Invalid_contextc'DEC_Invalid_operationc'DEC_Overflow c'DEC_Clamped c'DEC_Roundedc'DEC_Subnormalc'DEC_Underflowc'DEC_IEEE_754_Division_by_zeroc'DEC_IEEE_754_Inexact c'DEC_IEEE_754_Invalid_operationc'DEC_IEEE_754_Overflowc'DEC_IEEE_754_Underflow c'DEC_Errors c'DEC_NaNsc'DEC_Condition_Lengthc'DEC_INIT_BASEc'DEC_INIT_DECIMAL32c'DEC_INIT_DECIMAL64c'DEC_INIT_DECIMAL128c'DECQUAD_Bytesc'DECQUAD_Pmaxc'DECQUAD_Eminc'DECQUAD_Emaxc'DECQUAD_EmaxDc'DECQUAD_Biasc'DECQUAD_Stringc'DECQUAD_EconLc'DECQUAD_Decletsc'DECQUAD_Ehighp'decQuad'bytesp'decQuad'shortsp'decQuad'wordsc'DECFLOAT_Signc'DECFLOAT_NaNc'DECFLOAT_qNaNc'DECFLOAT_sNaNc'DECFLOAT_Infc'DECFLOAT_MinSp c'DECPPLUSALTc'DECPMINUSALT c'DECPPLUS c'DECPMINUSc'DECPPLUSALT2c'DECPUNSIGNEDQuadCtx toByteString AdjustedExp unAdjustedExpPayload unPayload Coefficient unCoefficientDigitD9D8D7D6D5D4D3D2D1D0DecodeddSigndValueValueNaNInfiniteFiniteExponent unExponent SignalingQuietSignSign1Sign0QuadTunQuadTDecClassFlagsFlagRound roundCeilingroundUp roundHalfUp roundHalfEven roundHalfDown roundDown roundFloor round05UpdivisionUndefineddivisionByZerodivisionImpossibleinvalidOperationinexact underflowoverflowconversionSyntaxunFlagssetFlag clearFlag checkFlag emptyFlags getStatus setStatus mapStatusgetRoundsetRoundrunCtxevalCtxsNanqNannegInf negNormal negSubnormalnegZeroposZero posSubnormal posNormalposInfabsaddanddecClasscompare compareOrd compareSignal compareTotalcompareTotalMagcopySigndigitsdivide divideIntegerfma fromInt32fromByteString fromUInt32invertisFinite isInfinite isInteger isLogicalisNaN isNegativeisNormal isPositive isSignalingisSigned isSubnormalisZerologBmaxmaxMagminminMagminusmultiply nextMinusnextPlus nextTowardorplusquantizereduce remainder remainderNearrotate sameQuantumscaleBshiftsubtracttoEngByteStringtoInt32 toInt32ExacttoIntegralExacttoIntegralValuetoUInt32 toUInt32Exactversionxorzeroone minMaxExp minNormalAdj minNormalExpexponent zeroExponenttoBCDfromBCD scientificordinarydecodedToRational digitToInt intToDigit digitToChar coefficientzeroCoefficientoneCoefficientpayload zeroPayloaddigitsToIntegerintegralToDigitscoefficientLen payloadLen dIsFinite dIsInfinite dIsInteger dIsLogicaldIsNaN dIsNegative dIsNormal dIsPositive dIsSignaling dIsSigned dIsSubnormaldIsZerodDigits adjustedExpadjustedToExponentdIsSNaNdIsQNaN dIsNegInf dIsNegNormaldIsNegSubnormal dIsNegZero dIsPosZerodIsPosSubnormal dIsPosNormal dIsPosInfDekaTunDekaTDekaunDeka DekaErrorFlagged IntegerTooBigintegralToDeka strToDeka quadToDekaexamples$fStorableC'decQuad$fStorableC'decContextbaseGHC.BaseString $fShowQuadMkStringunQuadunCtxmkString $fMonadCtx$fApplicativeCtx $fFunctorCtxghc-prim GHC.ClassesEqOrd GHC.Exception ExceptionnewQuad GHC.TypesOrdering $fShowFlags GetRoundedBooleanTernaryUnaryGet BinaryCtxFreeBinaryUnaryunRoundunarybinary binaryCtxFreeunaryGetternaryboolean getRoundedtoDecNumberBCD getDecoded sciFinitesciNaN onyFinite$fEnumAdjustedExp$fBoundedAdjustedExp $fEnumPayload$fBoundedPayload$fEnumCoefficient$fBoundedCoefficient$fEnumExponent$fBoundedExponent $fOrdQuadT $fEqQuadT$fShowDecClass$fExceptionFlags $fShowFlag $fShowRoundGHC.NumNumGHC.RealReal Fractional Data.MaybeNothing $fOrdDekaT $fEqDekaT $fNumDeka fromInteger $fOrdDeka$fEqDekaeval $fBoundedDeka $fRealDeka$fExceptionDekaError