h$42l7      !"#$%&'()*+,-./0123456*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstableportable (with CPP) Safe-Inferredt*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstable(semi-portable (OverlappingInstances,...) Safe-Inferred>i logfloatThis class defines a partially ordered type. The method names were chosen so as not to conflict with 7 and 8 . We use 9 instead of defining new types PartialOrdering and  FuzzyBool7 because this way should make the class easier to use.Minimum complete definition: logfloatlike :logfloatlike (;)logfloatlike (<)logfloatlike (=)logfloatlike (>)logfloatlike (?) logfloatlike (@) logfloatlike A. The default instance returns the left argument when they're equal. logfloatlike B. The default instance returns the left argument when they're equal. logfloatLike Data.Ord.comparing#. Helpful in conjunction with the xxxBy family of functions from  Data.List   44444 4 4 4*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstableportableNoneMlogfloatMany numbers are not C yet, even though they can represent arbitrarily large values, they are not necessarily able to represent transfinite values such as infinity itself. This class is for types which are capable of representing such values. Notably, this class does not require the type to be D nor E since integral types could also have representations for transfinite values. By popular demand the F restriction has been lifted as well, due to complications of defining G or 8 for some types.In particular, this class extends the ordered projection to have a maximum value  and a minimum value #, as well as an exceptional value ". All the natural laws regarding infinity and negativeInfinity6 should pertain. (Some of these are discussed below.)9Hugs (September 2006) has buggy Prelude definitions for  and  on Float and Double. This module provides correct definitions, so long as Hugs.RealFloat is compiled correctly.logfloatA transfinite value which is greater than all finite values. Adding or subtracting any finite value is a no-op. As is multiplying by any non-zero positive value (including infinity), and dividing by any positive finite value. Also obeys the law "negate infinity = negativeInfinity% with all appropriate ramifications.logfloatA transfinite value which is less than all finite values. Obeys all the same laws as infinity7 with the appropriate changes for the sign difference.logfloatAn exceptional transfinite value for dealing with undefined results when manipulating infinite values. The following operations must return  notANumber, where inf is any value which  isInfinite: infinity + negativeInfinity negativeInfinity + infinity infinity - infinity #negativeInfinity - negativeInfinity inf * 0 0 * inf  inf / inf  inf `div` inf 0 / 0  0 `div` 0-Additionally, any mathematical operations on  notANumber must also return  notANumber., and any equality or ordering comparison on  notANumber must return False (violating the law of the excluded middle, often assumed but not required for 8; thus,  and  are preferred over (=) and (>)). Since it returns false for equality, there may be more than one machine representation of this value.logfloatReturn true for both infinity and negativeInfinity, false for all other values.logfloatReturn true only for  notANumber.logfloatSince the normal H throws an error on zero, we have to redefine it in order for things to work right. Arguing from limits we can see that log 0 == negativeInfinity. Newer versions of GHC have this behavior already, but older versions and Hugs do not.This function will raise an error when taking the log of negative numbers, rather than returning  as the newer GHC implementation does. The reason being that typically this is a logical error, and  notANumber) allows the error to propagate silently.%In order to improve portability, the ) class is required to indicate that the E type does in fact have a representation for negative infinity. Both native floating types (I and J5) are supported. If you define your own instance of  Transfinite,, verify the above equation holds for your 0 and negativeInfinity6. If it doesn't, then you should avoid importing our log> and will probably want converters to handle the discrepancy.For GHC, this version of log has rules for fusion with exp. These can give different behavior by preventing overflow to infinity and preventing errors for taking the logarithm of negative values. For I and J they can also give different answers due to eliminating floating point fuzz. The rules strictly improve mathematical accuracy, however they should be noted in case your code depends on the implementation details.*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstable/semi-portable (CPP, MPTC, OverlappingInstances)None>logfloatThe K) function is defined to pivot through a L according to the haskell98 spec. This is non-portable and problematic as discussed in Data.Number.Transfinite. Since there is resistance to breaking from the spec, this class defines a reasonable variant which deals with transfinite values appropriately.There is a generic instance from any Transfinite Real to any Transfinite Fractional, using checks to ensure correctness. GHC has specialized versions for some types which use primitive converters instead, for large performance gains. (These definitions are hidden from other compilers via CPP.) Due to a bug in Haddock the specialized instances are shown twice and the generic instance isn't shown at all. Since the instances are overlapped, you'll need to give type signatures if the arguments to  are polymorphic. There's also a generic instance for any Real Fractional type to itself, thus if you write any generic instances beware of incoherence.If any of these restrictions (CPP, GHC-only optimizations, OverlappingInstances) are onerous to you, contact the maintainer (we like patches). Note that this does, work for Hugs with suitable options (e.g. hugs -98 +o -F'cpp -P' ). However, Hugs doesn't allow IncoherentInstances" nor does it allow diamonds with OverlappingInstances, which restricts the ability to add additional generic instances.*Copyright (c) 2007--2017 wren gayle romanoBSD3wren@community.haskell.orgstableportable (with CPP, FFI)None02G #logfloatA LogFloat is just a I% with a special interpretation. The & function is presented instead of the constructor, in order to ensure semantic conversion. At present the G instance will convert back to the normal-domain, and hence will underflow at that point. This behavior may change in the future. At present, the M instance parses things in the normal-domain and then converts them to the log-domain. Again, this behavior may change in the future.Because & performs the semantic conversion, we can use operators which say what we *mean* rather than saying what we're actually doing to the underlying representation. That is, equivalences like the following are true[1] thanks to type-class overloading: logFloat (p + q) == logFloat p + logFloat q logFloat (p * q) == logFloat p * logFloat q(Do note, however, that subtraction can and negation will throw errors: since LogFloat* can only represent the positive half of I. F is the wrong abstraction to put at the bottom of the numeric type-class hierarchy; but alas, we're stuck with it.)Performing operations in the log-domain is cheap, prevents underflow, and is otherwise very nice for dealing with miniscule probabilities. However, crossing into and out of the log-domain is expensive and should be avoided as much as possible. In particular, if you're doing a series of multiplications as in lp * logFloat q * logFloat r it's faster to do lp * logFloat (q * r) if you're reasonably sure the normal-domain multiplication won't underflow; because that way you enter the log-domain only once, instead of twice. Also note that, for precision, if you're doing more than a few multiplications in the log-domain, you should use , rather than using N repeatedly.#Even more particularly, you should avoid addition whenever possible. Addition is provided because sometimes we need it, and the proper implementation is not immediately apparent. However, between two LogFloats addition requires crossing the exp/log boundary twice; with a LogFloat and a I it's three times, since the regular number needs to enter the log-domain first. This makes addition incredibly slow. Again, if you can parenthesize to do normal-domain operations first, do it! 1That is, true up-to underflow and floating point fuzziness. Which is, of course, the whole point of this module.$logfloat Definition: expm1 == subtract 1 . exp9. Standard C libraries provide a special definition for $ which is more accurate than doing the naive thing, especially for very small arguments. This function isn't needed internally, but is provided for symmetry with %.6This installation was compiled to use the FFI version.%logfloat Definition: log1p == log . (1+)9. Standard C libraries provide a special definition for % which is more accurate than doing the naive thing, especially for very small arguments. For example, the naive version underflows around 2 ** -535, whereas the specialized version underflows around  2 ** -1074. This function is used by (O) and (P) on LogFloat. N.B. The statistics:Statistics.Math3 module provides a pure Haskell implementation of log1p for those who are interested. We do not copy it here because it relies on the vector package which is non-portable. If there is sufficient interest, a portable variant of that implementation could be made. Contact the maintainer if the FFI and naive implementations are insufficient for your needs.6This installation was compiled to use the FFI version.&logfloatConstructor which does semantic conversion from normal-domain to log-domain. Throws errors on negative and NaN inputs. If p4 is non-negative, then following equivalence holds: #logFloat p == logToLogFloat (log p)If p is NaN or negative, then the two sides differ only in which error is thrown.'logfloatConstructor which assumes the argument is already in the log-domain. Throws errors on  notANumber inputs.(logfloatSemantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogFloat == exp . logFromLogFloat)logfloat6Return the log-domain value itself without conversion.*logfloatO(1). Compute powers in the log-domain; that is, the following equivalence holds (modulo underflow and all that): 'logFloat (p ** m) == logFloat p `pow` m Since: 0.13+logfloatO(n)&. Compute the sum of a finite list of #s, being careful to avoid underflow issues. That is, the following equivalence holds (modulo underflow and all that): $logFloat . sum == sum . map logFloatN.B., this function requires two passes over the input. Thus, it is not amenable to list fusion, and hence will use a lot of memory when summing long lists. Since: 0.13,logfloatO(n)*. Compute the product of a finite list of #s, being careful to avoid numerical error due to loss of precision. That is, the following equivalence holds (modulo underflow and all that): ,logFloat . product == product . map logFloat Since: 0.13#$%&'()*+, #&(')+,*%$*8      !"#$%&'()*+,-./0123456789:;<=;<>?@A;<B;<C;<D;<E;<F;<G;<H;<I;<J?KL?MN?OP?QR?ST?O;UV;UW?M?MX?YZ?Q[?Q\?Q]&logfloat-0.13.4-Cucc6NhALEj6owmkVa9U0GHugs.RealFloatData.Number.PartialOrdData.Number.TransfiniteData.Number.RealToFracData.Number.LogFloat isInfiniteisNaN PartialOrdcmpgtgeeqneleltmaxPOminPO comparingPO$fPartialOrdDouble$fPartialOrdFloat $fPartialOrda TransfiniteinfinitynegativeInfinity notANumberlog$fTransfiniteFloat$fTransfiniteDouble RealToFrac realToFrac$fRealToFracDoubleFloat$fRealToFracFloatDouble$fRealToFracIntegerDouble$fRealToFracIntegerFloat$fRealToFracIntDouble$fRealToFracIntFloat$fRealToFracab$fRealToFracaaLogFloatexpm1log1plogFloat logToLogFloat fromLogFloatlogFromLogFloatpowsumproduct$fRealLogFloat$fFractionalLogFloat $fNumLogFloat$fShowLogFloat$fReadLogFloat$fPartialOrdLogFloat$fIArrayUArrayLogFloat $fEqLogFloat $fOrdLogFloat$fStorableLogFloatghc-prim GHC.ClassesOrdEqbase GHC.MaybeMaybecompare>>===/=<=<maxminGHC.EnumBoundedGHC.Real Fractional GHC.FloatFloatingGHC.NumNumGHC.ShowShow GHC.TypesDoubleFloatRationalGHC.ReadRead*+-