+]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Trustworthy 8 Et cetera9#A precision of 3 significant digits:#A precision of 2 significant digitsA precision of (p q) significant digitsA precision of (p + q) significant digitsF"A precision of 1 significant digitG+A precision of unlimited significant digitsH(A subclass of precisions that are finiteIXPrecision indicates the maximum number of significant decimal digits a number may have.J)Return the precision of the argument, or  if the precision is infinite.T  !"#$%&'()*+,-./0123456789:;<=A precision of (p + 9) significant digits>A precision of (p + 8) significant digits?A precision of (p + 7) significant digits@A precision of (p + 6) significant digitsAA precision of (p + 5) significant digitsBA precision of (p + 4) significant digitsCA precision of (p + 3) significant digitsDA precision of (p + 2) significant digitsEA precision of (p + 1) significant digitsFGHIJK  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJS  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ Trustworthy _Round zero or five away from 0`Round away from 0aIf the discarded digits represent greater than half (0.5) of the value of a one in the next left position then the value is rounded up. If they represent less than half or exactly half, the value is rounded down.bRound toward ""cRound toward +"dIf the discarded digits represent greater than half (0.5) of the value of a one in the next left position then the value is rounded up. If they represent less than half, the value is rounded down. If they represent exactly half, the value is rounded to make its rightmost digit even.eIf the discarded digits represent greater than or equal to half (0.5) of the value of a one in the next left position then the value is rounded up. If they represent less than half, the value is rounded down.fRound toward 0 (truncate)gpA rounding algorithm to use when the result of an arithmetic operation exceeds the precision of the result type&_`abcdefg_`abcdefg_`abcdefg TrustworthyKQA decimal floating point number with selectable precision and rounding algorithmMPositive or non-negativeNNegative4Return the number of decimal digits of the argument.0Compute an infinite series to maximum precision.QCompute the arcsine of the argument to maximum precision using series expansion.BCompute  to maximum precision using the arcsine series expansion.cCast a number with two additional digits of precision down to a number with the desired precision.A K representing the value zeroA K representing the value A K representing the value oneA K representing the value twoA K$ representing the value negative oneA K) representing the value positive infinityA K representing undefined results A signaling K representing undefined resultsNegate the given K by directly flipping its sign.sCast a K to another precision and/or rounding algorithm, immediately rounding if necessary to the new precision using the new algorithm.Is the sign of the given K positive?Is the sign of the given K negative?Does the given K represent a finite value?Does the given K represent the value zero? Is the given K normal? Is the given K subnormal?tReturn % if the argument is zero or NaN, and  otherwise.1Upper limit on the absolute value of the exponent&Minimum value of the adjusted exponent&Maximum value of the adjusted exponent3Minimum value of the exponent for subnormal results$Range of permissible exponent values@KLMNst     !KLMNst6K LMNst      TrustworthyhConvert a string to a number, as defined by its abstract representation. The string is expected to conform to the numeric string syntax described here.iRConvert a number to a string, using scientific notation if an exponent is needed.uSConvert a number to a string, using engineering notation if an exponent is needed.hiuhiuiuhhiu Trustworthy9;<=O,A representation of an exceptional conditionQRaised when the exponent of a result has been altered or constrained in order to fit the constraints of a specific concrete representationR2Raised when a non-zero dividend is divided by zeroSkRaised when a result is not exact (one or more non-zero coefficient digits were discarded during rounding)T5Raised when a result would be undefined or impossibleUCRaised when the exponent of a result is too large to be representedViRaised when a result has been rounded (that is, some zero or non-zero coefficient digits were discarded)WHRaised when a result is subnormal (its adjusted exponent is less than Emin), before any roundingX2Raised when a result is both subnormal and inexactY:A decimal arithmetic monad parameterized by the precision p and rounding algorithm rZ}A context for decimal arithmetic, carrying signal flags, trap enabler state, and a trap handler, parameterized by precision p and rounding algorithm r[1The defined result for the exceptional condition\Set the given signal flag in the context of the current arithmetic computation, and call the trap handler if the trap for this signal is currently enabled.]Evaluate an arithmetic computation in the given context and return the final value or exception, discarding the resulting context.^JReturn a new context with all signal flags cleared and all traps disabled.vA trap handler function may return a substitute result for the operation that caused the exceptional condition, or it may call G to abort the arithmetic computation (or pass control to an enclosing  handler).w/A group of signals can be manipulated as a set.x/The signal raised by the exceptional conditiony'The current signal flags of the context)The trap handler function for the contextzRReturn a new context with all signal flags cleared, all traps enabled except for S, V, and Wi, using a precision of 9 significant decimal digits, and rounding half up. Trapped signals simply call  with the corresponding O, and can be caught using .{Return a new context with all signal flags cleared, all traps disabled (IEEE 854 7), using selectable precision (the IEEE 754 smallest and basic formats correspond to precisions 5, ,, or -), and rounding half even (IEEE 754 4.3.3).|yEvaluate an arithmetic computation in the given context and return the final value (or exception) and resulting context.})Create a set of signals from a singleton.~$Create a set of signals from a list.#Enumerate the given set of signals.0Remove the first set of signals from the second.0Determine whether a signal is a member of a set.UClear the given signal flags from the context of the current arithmetic computation.6Evaluate an arithmetic computation within a modified context that enables the given signals to be trapped by the given handler. The previous trap handler (and enabler state) will be restored during any trap, as well as upon completion. Any existing trap handlers for signals not mentioned remain in effect.*OPQRSTUVWXYZ[\]^vwx yz{|}~O[xPUXQRSTVWYZy\]^vwz{|}~Zy^yz{Y|]Ox[x[PQRSTUVWXw}~\vOx[PQRSTUVWXYZ y\]^vwz{|}~ Trustworthy%jj takes two operands, compares their values numerically, and returns the maximum. If either operand is a NaN then the general rules apply, unless one is a quiet NaN and the other is numeric, in which case the numeric operand is returned.kk takes two operands, compares their values numerically, and returns the minimum. If either operand is a NaN then the general rules apply, unless one is a quiet NaN and the other is numeric, in which case the numeric operand is returned.llS takes two operands and compares their values numerically. If either operand is a  special valueV then the general rules apply. No flags are set unless an operand is a signaling NaN.0Otherwise, the operands are compared, returning -1( if the first is less than the second, 0 if they are equal, or 1* if the first is greater than the second.mmU takes one operand. If the operand is negative, the result is the same as using the nK operation on the operand. Otherwise, the result is the same as using the  operation on the operand.KNote that the result of this operation is affected by context and may set flags. The . operation may be used if this is not desired.nn[ takes one operand, and corresponds to the prefix minus operator in programming languages.KNote that the result of this operation is affected by context and may set flags. The " operation may be used instead of n if this is not desired.oo, takes two operands. If either operand is a  special value then the general rules apply.Otherwise, if the divisor is zero then either the Division undefined condition is raised (if the dividend is zero) and the result is NaN, or the Division by zero condition is raised and the result is an Infinity with a sign which is the exclusive or of the signs of the operands.)Otherwise, a long division  is effected.The result is then rounded to  precision) digits, if necessary, according to the roundingD algorithm and taking into account the remainder from the division.pp, takes two operands. If either operand is a  special value then the general rules apply. Otherwise, the operands are multiplied together ( long multiplication ), resulting in a number which may be as long as the sum of the lengths of the two operands.The result is then rounded to  precisionN digits if necessary, counting from the most significant digit of the result.qq, takes two operands. If either operand is a  special value then the general rules apply.6Otherwise, the operands are added after inverting the sign used for the second operand.The result is then rounded to  precisionN digits if necessary, counting from the most significant digit of the result.rr, takes two operands. If either operand is a  special value then the general rules apply."Otherwise, the operands are added.The result is then rounded to  precisionN digits if necessary, counting from the most significant digit of the result.ZeroNormal finite numberSubnormal finite numberInfinity!Not a number (quiet or signaling)Z takes one operand, and corresponds to the prefix plus operator in programming languages.KNote that the result of this operation is affected by context and may set flags.F takes two operands and compares their values numerically with their sign ignored and assumed to be 0.If, without signs, the first operand is the larger then the original first operand is returned (that is, with the original sign). If, without signs, the second operand is the larger then the original second operand is returned. Otherwise the result is the same as from the j operation.F takes two operands and compares their values numerically with their sign ignored and assumed to be 0.If, without signs, the first operand is the smaller then the original first operand is returned (that is, with the original sign). If, without signs, the second operand is the smaller then the original second operand is returned. Otherwise the result is the same as from the k operation.!Ordering function for k, , j, and c: returns the original arguments as (smaller, larger) when the given function is applied to them.5 takes one operand. It has the same semantics as the  operation, except that if the final result is finite it is reduced to its simplest form, with all trailing zeros removed and its sign preserved.T takes one operand. The result has the same value as the operand but always uses a  canonical encoding. The definition of  canonical is implementation-defined; if more than one internal encoding for a given NaN, Infinity, or finite number is possible then one preferred  encoding is deemed canonical. This operation then returns the value using that preferred encoding.EIf all possible operands have just one internal encoding each, then K always returns the operand unchanged (that is, it has the same effect as >). This operation is unaffected by context and is quiet  no flags are changed in the context.7 takes one operand. The result is an indication of the classd of the operand, where the class is one of ten possibilities, corresponding to one of the strings "sNaN" (signaling NaN), "NaN" (quiet NaN),  "-Infinity" (negative infinity),  "-Normal"# (negative normal finite number),  "-Subnormal"% (negative subnormal finite number), "-Zero" (negative zero), "+Zero" (non-negative zero),  "+Subnormal"& (positive subnormal finite number),  "+Normal"& (positive normal finite number), or  "+Infinity"2 (positive infinity). This operation is quiet; no flags are changed in the context.Note that unlike the special values in the model, the sign of any NaN is ignored in the classification, as required by IEEE 754.t takes one operand. The result is a copy of the operand. This operation is unaffected by context and is quiet  no flags are changed in the context.B takes one operand. The result is a copy of the operand with the sign set to 0. Unlike the mG operation, this operation is unaffected by context and is quiet  no flags are changed in the context.B takes one operand. The result is a copy of the operand with the sign inverted (a sign- of 0 becomes 1 and vice versa). Unlike the nG operation, this operation is unaffected by context and is quiet  no flags are changed in the context.I takes two operands. The result is a copy of the first operand with the sign set to be the same as the signS of the second operand. This operation is unaffected by context and is quiet  no flags are changed in the context.7 takes one operand. The result is 1 if the operand is  canonical'; otherwise it is 0. The definition of  canonical is implementation-defined; if more than one internal encoding for a given NaN, Infinity, or finite number is possible then one preferred  encoding is deemed canonical. This operation then tests whether the internal encoding is that preferred encoding.EIf all possible operands have just one internal encoding each, then N always returns 1. This operation is unaffected by context and is quiet  no flags are changed in the context. takes one operand. The result is 1 if the operand is neither infinite nor a NaN (that is, it is a normal number, a subnormal number, or a zero); otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context. takes one operand. The result is 1 if the operand is an Infinity; otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context. takes one operand. The result is 1 if the operand is a NaN (quiet or signaling); otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context.N takes one operand. The result is 1 if the operand is a positive or negative  normal number2; otherwise it is 0. This operation is quiet; no flags are changed in the context. takes one operand. The result is 1 if the operand is a quiet NaN; otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context.+ takes one operand. The result is 1 if the signe of the operand is 1; otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context. takes one operand. The result is 1 if the operand is a signaling NaN; otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context.N takes one operand. The result is 1 if the operand is a positive or negative subnormal number2; otherwise it is 0. This operation is quiet; no flags are changed in the context. takes one operand. The result is 1 if the operand is a zero; otherwise it is 0. This operation is unaffected by context and is quiet  no flags are changed in the context. takes no operands. The result is the radix (base) in which arithmetic is effected; for this specification the result will have the value 10.F takes two operands, and returns 1 if the two operands have the same exponentg or 0 otherwise. The result is never affected by either the sign or the coefficient of either operand.If either operand is a  special valueG, 1 is returned only if both operands are NaNs or both are infinities. does not change any flags in the context.5jklmnopqr"#$%&'()*+,!-*LMNjklmnopqr*mrqlojknpLMN/jklmnopqr"#$%&'()*+,!->General arbitrary-precision decimal floating-point number type 2016 Robert LeslieBSD3 rob@mars.org experimental Trustworthy7A decimal floating point number with infinite precisionNA decimal floating point number with selectable precision, rounding half evenMA decimal floating point number with 9 digits of precision, rounding half upZ  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK_`abcdefgstZKIJHF:9876543210/.-,+*)('&%$#"!  EDCBA@?>=<;Ggedacb`_fst.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~nmlkjihg     aWb !"#$%&'()*1decimal-arithmetic-0.2.0.0-BzW3hGmNaLy7CwWenoeAjmNumeric.DecimalNumeric.Decimal.OperationNumeric.Decimal.ArithmeticNumeric.Decimal.ConversionNumeric.Decimal.PrecisionNumeric.Decimal.RoundingNumeric.Decimal.NumberP2000P1000P500P400P300P250P200P150P100P75P50P49P48P47P46P45P44P43P42P41P40P39P38P37P36P35P34P33P32P31P30P29P28P27P26P25P24P23P22P21P20P19P18P17P16P15P14P13P12P11P10P9P8P7P6P5P4P3P2PTimes10PTimes2PPlus9PPlus8PPlus7PPlus6PPlus5PPlus4PPlus3PPlus2PPlus1P1 PInfiniteFinitePrecision Precision precisionDecimalSignPosNeg ExceptionSignalClampedDivisionByZeroInexactInvalidOperationOverflowRounded Subnormal UnderflowArithContextexceptionResult raiseSignal evalArith newContext Round05UpRoundUp RoundHalfDown RoundFloor RoundCeiling RoundHalfEven RoundHalfUp RoundDownRoundingtoNumbertoScientificStringmaxmincompareabsminusdividemultiplysubtractaddcasttoBooltoEngineeringString TrapHandlerSignalsexceptionSignalflagsbasicDefaultContextextendedDefaultContextrunArithsignalsignals signalMember clearFlagstrap$fMonoidSignals $fShowSignals$fMonadStateContextArith$fMonadErrorExceptionArith $fMonadArith$fApplicativeArith$fFunctorArith $fEqSignal $fEnumSignal$fBoundedSignal $fShowSignal $fEqSignals$fShowExceptionSubclass ZeroClass NormalClassSubnormalClass InfinityClassNaNClassClassplus maxMagnitude minMagnitudereduce canonicalclass_copycopyAbs copyNegatecopySign isCanonicalisFinite isInfiniteisNaNisNormalisQNaNisSignedisSNaN isSubnormalisZeroradix sameQuantum $fShowClass $fEqSubclass $fEqClassGeneralDecimalExtendedDecimal BasicDecimalPTimesPPlusbaseGHC.BaseNothing$fFinitePrecisionPTimes$fPrecisionPTimes$fFinitePrecisionPPlus$fPrecisionPPlus$fFinitePrecisionP1 $fPrecisionP1$fPrecisionPInfiniteroundingroundRoundingAlgorithm excessDigitsrounded roundDown roundHalfUp roundHalfEven roundCeiling roundFloor roundHalfDownroundUp round05Up$fRoundingRound05Up$fRoundingRoundUp$fRoundingRoundHalfDown$fRoundingRoundFloor$fRoundingRoundCeiling$fRoundingRoundHalfEven$fRoundingRoundHalfUp$fRoundingRoundDown numDigitsinfiniteSeriesarcsineseriesPicastDownzerooneHalfonetwo negativeOneinfinityqNaNsNaNflipSign isPositive isNegativeghc-prim GHC.TypesFalseTrueeLimiteMineMaxeTinyeRangeNumInfQNaNSNaNsign coefficientexponentpayloadPayloadExponent Coefficient negateSignxorSignssignFunc signMatchevalOp enumFromWithnotyetmaxCoefficientadjustedExponent$fRealFloatDecimal$fFloatingDecimal$fRealFracDecimal$fFractionalDecimal $fRealDecimal $fNumDecimal $fEnumDecimal $fOrdDecimal $fEqDecimal$fPrecisionDecimal $fReadDecimal $fShowDecimal showNumber showExponent mtl-2.2.1-6qsR1PHUy5lL47Hpoa4jCMControl.Monad.Error.Class throwError catchError trapHandler signalListunsignalminMax RemainderQuotientDivisorDividendfinitePrecision roundingAlgresultinvalidOperationtoQNaNtoQNaN2 longDivision withoutSign