*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstableportable (with CPP) Safe-Inferred*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstable(semi-portable (OverlappingInstances,...)None24 fThis class defines a partially ordered type. The method names were chosen so as not to conflict with   and ! . We use " instead of defining new types PartialOrdering and  FuzzyBool7 because this way should make the class easier to use.Minimum complete definition: like #like ($)like (%)like (&)like (')like (() like ()) like *E. The default instance returns the left argument when they're equal. like +E. The default instance returns the left argument when they're equal. Like Data.Ord.comparing#. Helpful in conjunction with the xxxBy family of functions from  Data.List ,-.     ,-.   *Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstableportableNone Many numbers are not / 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 0 nor 1f since integral types could also have representations for transfinite values. By popular demand the 2H restriction has been lifted as well, due to complications of defining 3 or ! for some types.RIn 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 L on Float and Double. This module provides correct definitions, so long as Hugs.RealFloat is compiled correctly.A 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 infinityB), and dividing by any positive finite value. Also obeys the law "negate infinity = negativeInfinity% with all appropriate ramifications.VA transfinite value which is less than all finite values. Obeys all the same laws as infinity7 with the appropriate changes for the sign difference.An 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 FalseQ (violating the law of the excluded middle, often assumed but not required for !; thus,  and  are preferred over (&) and ('d)). Since it returns false for equality, there may be more than one machine representation of this value.Return true for both infinity and negativeInfinity, false for all other values.Return true only for  notANumber.Since the normal 4z 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 == negativeInfinityY. Newer versions of GHC have this behavior already, but older versions and Hugs do not.bThis function will raise an error when taking the log of negative numbers, rather than returning f 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 1^ type does in fact have a representation for negative infinity. Both native floating types (5 and 65) 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 infinityI and preventing errors for taking the logarithm of negative values. For 5 and 6 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. 78   78*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstable/semi-portable (CPP, MPTC, OverlappingInstances)None246;The 9) function is defined to pivot through a :X 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 OverlappingInstancesC, which restricts the ability to add additional generic instances. ;<=>?@AB ;<=>?@AB*Copyright (c) 2007--2015 wren gayle romanoBSD3wren@community.haskell.orgstableportable (with CPP, FFI)None B A LogFloat is just a 5% with a special interpretation. The k function is presented instead of the constructor, in order to ensure semantic conversion. At present the 3 instance will convert back to the normal-domain, and hence will underflow at that point. 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: WlogFloat (p + q) == logFloat p + logFloat q logFloat (p * q) == logFloat p * logFloat qO(Do note, however, that subtraction can and negation will throw errors: since LogFloat* can only represent the positive half of 5. 2u 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 '(*)' 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 LogFloatAs addition requires crossing the exp/log boundary twice; with a LogFloat and a 5 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! 1qThat is, true up-to underflow and floating point fuzziness. Which is, of course, the whole point of this module. 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. 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 (C) and (D) on LogFloat. N.B. The statistics:Statistics.Math3 module provides a pure Haskell implementation of log1pP 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.E?Reduce the number of constant string literals we need to store.{Constructor 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 pN is NaN or negative, then the two sides differ only in which error is thrown.WConstructor which assumes the argument is already in the log-domain. Throws errors on  notANumber inputs.Semantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogFloat == exp . logFromLogFloat6Return the log-domain value itself without conversion.O(1)n. 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.13O(n)&. Compute the sum of a finite list of ws, 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.13O(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.13FEGHIJKLM  FEGHIJKLMN      !"#$%&$%'()*$%+$%,$%-$%.$%/$%0$%1$%2$%3456(78(9:(;<(=>(?@(;$AB$ACDE(9(9FGHIJKLMN(=O(=PQRSTUVWXYlogfloat-0.13.1Hugs.RealFloatData.Number.PartialOrdData.Number.TransfiniteData.Number.RealToFracData.Number.LogFloat isInfiniteisNaN PartialOrdcmpgtgeeqneleltmaxPOminPO comparingPO TransfiniteinfinitynegativeInfinity notANumberlog RealToFrac realToFracLogFloatexpm1log1plogFloat logToLogFloat fromLogFloatlogFromLogFloatpowsumproductghc-prim GHC.ClassesOrdEqbase Data.MaybeMaybecompare>>===/=<=<maxmin$fPartialOrdDouble$fPartialOrdFloat $fPartialOrdaGHC.EnumBoundedGHC.Real Fractional GHC.FloatFloatingGHC.NumNumGHC.ShowShow GHC.TypesDoubleFloat$fTransfiniteFloat$fTransfiniteDoubleRational$fRealToFracDoubleFloat$fRealToFracFloatDouble$fRealToFracIntegerDouble$fRealToFracIntegerFloat$fRealToFracIntDouble$fRealToFracIntFloat$fRealToFracab$fRealToFracaa+-errorOutOfRangeguardNonNegativeguardIsANumber$fRealLogFloat$fFractionalLogFloat $fNumLogFloat$fShowLogFloat$fPartialOrdLogFloat