!L&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneDb-numhask Ha - a = zero negate a = zero - a negate a + a = zero a + negate a = zeronumhaskFor practical reasons,  has no super classes. Using  Associative and Unital from this library, or using  Semigroup and Monoid from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication. Ezero + a == a a + zero == a (a + b) + c == a + (b + c) a + b == b + aBy convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative multiplication seems a bit dogmatic.numhaskCompute the sum of a Foldable.66Safe=?DbF )numhaskAn  +https://en.wikipedia.org/wiki/Abelian_group Abelian Groupn is an Associative, Unital, Invertible and Commutative Magma . In other words, it is a Commutative Group*numhask9An Idempotent Magma is a magma where every element is  )https://en.wikipedia.org/wiki/Idempotence Idempotent.  a magma a = a+numhask#An Absorbing is a Magma with an /https://en.wikipedia.org/wiki/Absorbing_elementAbsorbing Element a `times` absorb = absorb-numhaskA  1https://en.wikipedia.org/wiki/Group_(mathematics)Group2 is a Associative, Unital and Invertible Magma..numhaskAn Invertible Magma H" a,b " T: inv a `magma` (a `magma` b) = b = (b `magma` a) `magma` inv a0numhask>A Commutative Magma is a Magma where the binary operation is  2https://en.wikipedia.org/wiki/Commutative_property commutative. a magma b = b magma a1numhaskAn Associative Magma )(a magma b) magma c = a magma (b magma c)2numhask%A Unital Magma is a magma with an  .https://en.wikipedia.org/wiki/Identity_elementidentity element (the unit). !unit magma a = a a magma unit = a4numhaskA  -https://en.wikipedia.org/wiki/Magma_(algebra)Magma# is a tuple (T,magma) consisting of a type a, and!a function (magma) :: T -> T -> T&The mathematical laws for a magma are:6magma is defined for all possible pairs of type T, and;magma is closed in the set of all possible values of type Tor, more tersly, " a, b " T: a magma b " TFThese laws are true by construction in haskell: the type signature of 5. and the above mathematical laws are synonyms. )*+,-./012345 452310+,./*-)NoneDbP?numhask Aa / a = one recip a = one / a recip a * a = one a * recip a = oneBnumhaskFor practical reasons, B has no super classes. Using  Associative and Unital from this library, or using  Semigroup and Monoid from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication. Cone * a == a a * one == a (a * b) * c == a * (b * c) a * b == b * aBy convention, (*) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative multiplication seems a bit dogmatic.EnumhaskCompute the product of a Foldable.?A@BCDEBCDE?A@A7C7None >@ADHVbSenumhaskIa type class to represent an action on elements of a higher-kinded number YZ[\]^_`abcde ebcd_`a\]^YZ[Z7[7]7^7`6a6c6d6None=?DbofnumhaskInvolutive Ring ]adj (a + b) ==> adj a + adj b adj (a * b) ==> adj a * adj b adj one ==> one adj (adj a) ==> aNote: elements for which  adj a == a are called "self-adjoint".hnumhaskA  ,https://en.wikipedia.org/wiki/Kleene_algebraKleene Algebra/ is a Star Semiring with idempotent addition aa `times` x + x = a ==> star a `times` x + x = x x `times` a + x = a ==> x `times` star a + x = xinumhaskA  5https://en.wikipedia.org/wiki/Semiring#Star_semirings StarSemiringD is a semiring with an additional unary operator star satisfying: star a = one + a `times` star alnumhaskAn  -https://en.wikipedia.org/wiki/Integral_domainIntegral Domain generalizes a ring of integers by requiring the product of any two nonzero elements to be nonzero. This means that if a "` 0, an equality ab = ac implies b = c.mnumhaskA  0https://en.wikipedia.org/wiki/Ring_(mathematics)Ring is an abelian group under addition and monoidal under multiplication, and where multiplication distributes over addition.nnumhaskA  &https://en.wikipedia.org/wiki/SemiringSemiring is commutative monoidal under addition, has a monoidal multiplication operator (not necessarily commutative), and where multiplication distributes over addition.onumhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive laws [a * (b + c) == a * b + a * c (a * b) * c == a * c + b * c zero * a == zero a * zero == zeroThe sneaking in of the  /https://en.wikipedia.org/wiki/Absorbing_element annihilation laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.pnumhask Defining p5 requires adding the multiplicative unital to itself. fghijklmnop onmlijkhfgpNone>@ADbt[numhaskA  2https://en.wikipedia.org/wiki/Module_(mathematics)Modulee over r a is a (Ring a), an abelian (Group r a) and a scalar multiplier (.*, *.) with the laws: xa .* one == a (a + b) .* c == (a .* c) + (b .* c) c *. (a + b) == (c *. a) + (c *. b) a .* zero == zero a .* b == b *. a None =?@ADXbx!numhaskelement by element division a ./. a == singleton onenumhask!element by element multiplication e(a .*. b) .*. c == a .*. (b .*. c) singleton one .*. a = a a .*. singleton one = a a .*. b == b .*. a77 None,8=>?@ADHVb5numhaskghc defaulting rules and, it seems, -XExtendedDefaultRules do not permit multiple parameter typeclasses to be in the mix when types are resolved, hence the simpler `type FromInteger a = FromIntegral a Integer` does not suffice.numhaskkfromIntegral abstracts the codomain type, compared with the preludes Integral type. > fromIntegral_ a == aWfromIntegral is widely used as general coercion, hence the underscore for the operator.numhaskatoIntegral is kept separate from Integral to help with compatability issues. > toIntegral a == anumhask Integral laws /b == zero || b * (a `div` b) + (a `mod` b) == anumhaskgeneral coercion via Integernumhask/raise a number to a non-negative integral power77 None 8=>?@ADXbknumhaskTrigonometric Fieldnumhask`A bounded field includes the concepts of infinity and NaN, thus moving away from error throwing. Mone / zero + infinity == infinity infinity + a == infinity zero / zero != nan}Note the tricky law that, although nan is assigned to zero/zero, they are never-the-less not equal. A committee decided this.numhaskA hyperbolic field class Ysqrt . (**2) == identity log . exp == identity for +ive b, a != 0,1: a ** logBase a b "H bnumhaskA  1https://en.wikipedia.org/wiki/Field_(mathematics)Field is a set on which addition, subtraction, multiplication, and division are defined. It is also assumed that multiplication is distributive over addition.AA summary of the rules thus inherited from super-classes of Field pzero + a == a a + zero == a (a + b) + c == a + (b + c) a + b == b + a a - a = zero negate a = zero - a negate a + a = zero a + negate a = zero one * a == a a * one == a (a * b) * c == a * (b * c) a * (b + c) == a * b + a * c (a + b) * c == a * c + b * c a * zero == zero zero * a == zero a * b == b * a a / a = one recip a = one / a recip a * a = one a * recip a = onenumhaskA  is a J because it requires addition, multiplication and division to be computed.!     !      None=?Db~1numhaskLattices with both bounds2numhask,A meet-semilattice with an identity element 3 for 8. Identity: x /\ top == x4numhask,A join-semilattice with an identity element 5 for :. Identity: x \/ bottom == x6numhaskWThe combination of two semi lattices makes a lattice if the absorption law holds: see  +http://en.wikipedia.org/wiki/Absorption_law and ,http://en.wikipedia.org/wiki/Lattice_(order) /Absorption: a \/ (a /\ b) == a /\ (a \/ b) == a7numhask*A algebraic structure with element meets: (http://en.wikipedia.org/wiki/Semilattice hAssociativity: x /\ (y /\ z) == (x /\ y) /\ z Commutativity: x /\ y == y /\ x Idempotency: x /\ x == x9numhask*A algebraic structure with element joins: (http://en.wikipedia.org/wiki/Semilattice hAssociativity: x \/ (y \/ z) == (x \/ y) \/ z Commutativity: x \/ y == y \/ x Idempotency: x \/ x == x;numhask>The partial ordering induced by the join-semilattice structure<numhask>The partial ordering induced by the meet-semilattice structure 123456789:;< 9:;78<64523186:5 None=?@ADbnumhask1distance between numbers using L1, L2 or Lp-norms distanceL2 a b >= zero distanceL2 a a == zero \a b c -> distanceL2 a c + distanceL2 b c - distanceL2 a b >= zero && distanceL2 a b + distanceL2 b c - distanceL2 a c >= zero && distanceL2 a b + distanceL2 a c - distanceL2 b c >= zero &&numhaskWL1 and L2 norms are provided for potential speedups, as well as the generalized p-norm. for p >= 1 (normLp p a >= zero normLp p zero == zero=Note that the Normed codomain can be different to the domain.numhaskz from base is not an operator replicated in numhask, being such a very silly name, and preferred is the much more obvious . Compare with Norm$ where there is a change in codomain abs a * sign a == aGeneralising this class tends towards size and direction (abs is the size on the one-dim number line of a vector with its tail at zero, and sign is the direction, right?).|}~|}~4None 24567=?@ADbȜnumhask&Complex numbers are an algebraic type.For a complex number z,  z# is a number with the magnitude of z8, but oriented in the positive real direction, whereas  z has the phase of z, but unit magnitude.The  and ( instances traverse the real part first.numhaskKforms a complex number from its real and imaginary rectangular components.numhask+Extracts the real part of a complex number.numhask0Extracts the imaginary part of a complex number.numhask t# is a complex value with magnitude 1 and phase t (modulo 2*).numhask The function  takes a complex number and returns a (magnitude, phase) pair in canonical form: the magnitude is nonnegative, and the phase in the range (-, ]2; if the magnitude is zero, then so is the phase.numhask.The nonnegative magnitude of a complex number.numhask,The phase of a complex number, in the range (-, ]2. If the magnitude is zero, then so is the phase.  6NoneDbEa)*+,-./012345?A@BCDEYZ[\]^_`abcdefghijklmnop     123456789:;<None,8=>?@ADHVXbnumhask"with RebindableSyntax the literal '1.0'6 mean exactly `fromRational (1.0::GHC.Real.Rational)`.numhask Fractional in base splits into fromRatio and Field FIXME: work out why the default type isn't firing so that an explicit instance is needed for `FromRatio (Ratio Integer) Integer`numhasktoRatio is equivalent to Real2 in base, but is polymorphic in the Integral type.numhaskThese common constraints over the Ratio instances are due to the gcd algorithm. Subtractive is somewhat problematic with obtaining a `Ratio (Positive Integer)` which should be made possible.numhaskiGiven that fromRational is reserved, fromRational' provides general conversion between numhask rationals.numhask is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.numhask x y$ is the non-negative factor of both x and y" of which every common factor of x and y is also a factor; for example  4 2 = 2,  (-4) 6 = 2,  0 4 = 4.  0 0 = 0U. (That is, the common divisor that is "greatest" in the divisibility preordering.)2Note: Since for signed fixed-width integer types,  minBound < 09, the result may be negative if one of the arguments is minBound& (and necessarily is if the other is 0 or minBound) for such types.None7=>?@ADHVbgnumhaskLA pair of a's, implemented as a tuple, but api represented as a Pair of a's.fmap (+1) (Pair 1 2)Pair 2 3pure one :: Pair IntPair 1 1(*) <$> Pair 1 2 <*> pure 2Pair 2 4foldr (++) [] (Pair [1,2] [3])[1,2,3]FPair "a" "pair" `mappend` pure " " `mappend` Pair "string" "mappended" Pair "a string" "pair mappended"As a Ring and Field classPair 0 1 + zeroPair 0 1Pair 0 1 + Pair 2 3Pair 2 4Pair 1 1 - onePair 0 0Pair 0 1 * onePair 0 1Pair 0.0 1.0 / one Pair 0.0 1.0Pair 11 12 `mod` (pure 6)Pair 5 0 As an action Pair 1 2 .+ 3Pair 4 5!numhaskthe preferred pattern ! !None 24567=?@ADb$JnumhaskModule : Data.Number.LogFloat Copyright : Copyright (c) 2007--2015 wren gayle romano License : BSD3 Maintainer : wren@community.haskell.org Stability : stable Portability : portable (with CPP, FFI) Link : ,https://hackage.haskell.org/package/logfloatA LogField is just a % with a special interpretation. The Jk function is presented instead of the constructor, in order to ensure semantic conversion. At present the  instance will convert back to the normal-domain, and hence will underflow at that point. This behavior may change in the future.Because K 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: WlogField (p + q) == logField p + logField q logField (p * q) == logField p * logField q: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 * LogField q * LogField r it's faster to do lp * LogField (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 E$ 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 LogFieldAs addition requires crossing the exp/log boundary twice; with a LogField and a  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.Knumhask{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: #logField p == logToLogField (log p)LnumhaskEConstructor which assumes the argument is already in the log-domain.MnumhaskSemantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogField == exp . logFromLogFieldNnumhask6Return the log-domain value itself without conversion.OnumhaskO(1)n. Compute powers in the log-domain; that is, the following equivalence holds (modulo underflow and all that): 'LogField (p ** m) == LogField p `pow` m Since: 0.13PnumhaskO(n)&. Compute the sum of a finite list of Jws, being careful to avoid underflow issues. That is, the following equivalence holds (modulo underflow and all that): 4LogField . accurateSum == accurateSum . map LogFieldN.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.QnumhaskO(n)*. Compute the product of a finite list of Js, being careful to avoid numerical error due to loss of precision. That is, the following equivalence holds (modulo underflow and all that): <LogField . accurateProduct == accurateProduct . map LogFieldJKLMNOPQJKMLNPQOO8None =>?@ADIMb%jnopnopSafeDb%None =>?@ADIMb&v !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                               !"#$%&'()*+,-./01234567689:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#numhask-0.5.0-WwF6GEfa9kCsNkAjdvMIeNumHask.Data.RationalNumHask.Exception!NumHask.Algebra.Abstract.AdditiveNumHask.Algebra.Abstract.Group'NumHask.Algebra.Abstract.MultiplicativeNumHask.Algebra.Abstract.ActionNumHask.Algebra.Abstract.RingNumHask.Algebra.Abstract.ModuleNumHask.Algebra.Linear.HadamardNumHask.Data.IntegralNumHask.Algebra.Abstract.Field NumHask.Algebra.Abstract.LatticeNumHask.Analysis.MetricNumHask.Data.ComplexNumHask.Data.PairNumHask.Data.LogFieldNumHask.Data.WrappedNumHask.Data.PositiveNumHask.Algebra.AbstractbaseGHC.RealRational GHC.Exceptionthrow Subtractivenegate-Additive+zerosum $fAdditive->$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveNatural$fAdditiveBool$fAdditiveInteger $fAdditiveInt$fAdditiveFloat$fAdditiveDouble$fSubtractive->$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveNatural$fSubtractiveBool$fSubtractiveInteger$fSubtractiveInt$fSubtractiveFloat$fSubtractiveDouble AbelianGroup Idempotent AbsorbingabsorbGroup Invertibleinv Commutative AssociativeUnitalunitMagmamagma $fMagma-> $fUnital->$fAssociative->$fCommutative->$fInvertible->$fGroupa $fAbsorbing->$fIdempotent->$fAbelianGroupaDivisiverecip/Multiplicative*oneproduct$fMultiplicative->$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble $fDivisive->$fDivisiveFloat$fDivisiveDoubleDivisiveAction.//.MultiplicativeAction.**.SubtractiveAction.--.AdditiveAction.++.ActorInvolutiveRingadj KleeneAlgebra StarSemiringstarplusIntegralDomainRingSemiring Distributivetwo$fDistributive->$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble $fSemiringa$fRinga$fIntegralDomain->$fIntegralDomainFloat$fIntegralDomainDouble$fStarSemiring->$fKleeneAlgebra->$fInvolutiveRing->$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleHadamardHadamardDivision./.HadamardMultiplication.*. $fHadamardma FromInteger fromInteger FromIntegral fromIntegral_ ToInteger ToIntegral toIntegralIntegraldivmoddivModquotremquotRem toInteger fromIntegralevenodd^^^ $fIntegral->$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralNatural$fIntegralInteger $fIntegralInt$fToIntegralWord64Word64$fToIntegralWord32Word32$fToIntegralWord16Word16$fToIntegralWord8Word8$fToIntegralWordWord$fToIntegralInt64Int64$fToIntegralInt32Int32$fToIntegralInt16Int16$fToIntegralInt8Int8$fToIntegralNaturalNatural$fToIntegralIntInt$fToIntegralWord64Integer$fToIntegralWord32Integer$fToIntegralWord16Integer$fToIntegralWord8Integer$fToIntegralWordInteger$fToIntegralInt64Integer$fToIntegralInt32Integer$fToIntegralInt16Integer$fToIntegralInt8Integer$fToIntegralNaturalInteger$fToIntegralIntInteger$fToIntegralIntegerInteger$fFromIntegralWord64Word64$fFromIntegralWord32Word32$fFromIntegralWord16Word16$fFromIntegralWord8Word8$fFromIntegralWordWord$fFromIntegralInt64Int64$fFromIntegralInt32Int32$fFromIntegralInt16Int16$fFromIntegralInt8Int8$fFromIntegralNaturalNatural$fFromIntegralIntInt$fFromIntegralWord64Integer$fFromIntegralWord32Integer$fFromIntegralWord16Integer$fFromIntegralWord8Integer$fFromIntegralWordInteger$fFromIntegralInt64Integer$fFromIntegralInt32Integer$fFromIntegralInt16Integer$fFromIntegralInt8Integer$fFromIntegralNaturalInteger$fFromIntegralIntegerInteger$fFromIntegralIntInteger$fFromIntegralFloatInteger$fFromIntegralDoubleInteger$fFromIntegral->b$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerFloat$fFromIntegerDouble$fFromIntegerInt$fFromIntegerInteger TrigFieldpisincostanasinacosatansinhcoshtanhasinhacoshatanhLowerBoundedField negInfinityUpperBoundedFieldinfinitynan QuotientFieldproperFractionroundceilingfloortruncateExpFieldexploglogBase**sqrtFieldhalf $fField-> $fFieldFloat $fFieldDouble $fExpField->$fExpFieldFloat$fExpFieldDouble$fQuotientField->->$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedField->$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedField->$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat $fTrigField->$fTrigFieldFloat$fTrigFieldDoubleBoundedLatticeBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomLatticeMeetSemiLattice/\JoinSemiLattice\/joinLeqmeetLeq$fJoinSemiLattice->$fJoinSemiLatticeWord64$fJoinSemiLatticeWord32$fJoinSemiLatticeWord16$fJoinSemiLatticeWord8$fJoinSemiLatticeWord$fJoinSemiLatticeInt64$fJoinSemiLatticeInt32$fJoinSemiLatticeInt16$fJoinSemiLatticeInt8$fJoinSemiLatticeNatural$fJoinSemiLatticeBool$fJoinSemiLatticeInteger$fJoinSemiLatticeInt$fJoinSemiLatticeDouble$fJoinSemiLatticeFloat$fMeetSemiLattice->$fMeetSemiLatticeWord64$fMeetSemiLatticeWord32$fMeetSemiLatticeWord16$fMeetSemiLatticeWord8$fMeetSemiLatticeWord$fMeetSemiLatticeInt64$fMeetSemiLatticeInt32$fMeetSemiLatticeInt16$fMeetSemiLatticeInt8$fMeetSemiLatticeNatural$fMeetSemiLatticeBool$fMeetSemiLatticeInteger$fMeetSemiLatticeInt$fMeetSemiLatticeDouble$fMeetSemiLatticeFloat $fLatticea$fBoundedJoinSemiLattice->$fBoundedJoinSemiLatticeWord64$fBoundedJoinSemiLatticeWord32$fBoundedJoinSemiLatticeWord16$fBoundedJoinSemiLatticeWord8$fBoundedJoinSemiLatticeWord$fBoundedJoinSemiLatticeInt64$fBoundedJoinSemiLatticeInt32$fBoundedJoinSemiLatticeInt16$fBoundedJoinSemiLatticeInt8$fBoundedJoinSemiLatticeNatural$fBoundedJoinSemiLatticeBool$fBoundedJoinSemiLatticeInt$fBoundedJoinSemiLatticeDouble$fBoundedJoinSemiLatticeFloat$fBoundedMeetSemiLattice->$fBoundedMeetSemiLatticeWord64$fBoundedMeetSemiLatticeWord32$fBoundedMeetSemiLatticeWord16$fBoundedMeetSemiLatticeWord8$fBoundedMeetSemiLatticeWord$fBoundedMeetSemiLatticeInt64$fBoundedMeetSemiLatticeInt32$fBoundedMeetSemiLatticeInt16$fBoundedMeetSemiLatticeInt8$fBoundedMeetSemiLatticeBool$fBoundedMeetSemiLatticeInt$fBoundedMeetSemiLatticeDouble$fBoundedMeetSemiLatticeFloat$fBoundedLatticeaEpsilonepsilonnearZero aboutEqualMetric distanceL1 distanceL2NormednormL1normL2Signedsignabs~=$fSignedWord64$fSignedWord32$fSignedWord16 $fSignedWord8 $fSignedWord $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8$fSignedNatural$fSignedInteger $fSignedInt $fSignedFloat$fSignedDouble$fNormedWord64Word64$fNormedWord32Word32$fNormedWord16Word16$fNormedWord8Word8$fNormedWordWord$fNormedInt64Int64$fNormedInt32Int32$fNormedInt16Int16$fNormedInt8Int8$fNormedNaturalNatural$fNormedIntegerInteger$fNormedIntInt$fNormedFloatFloat$fNormedDoubleDouble$fMetricWord64Word64$fMetricWord32Word32$fMetricWord16Word16$fMetricWord8Word8$fMetricWordWord$fMetricInt64Int64$fMetricInt32Int32$fMetricInt16Int16$fMetricInt8Int8$fMetricNaturalNatural$fMetricIntegerInteger$fMetricIntInt$fMetricFloatFloat$fMetricDoubleDouble$fEpsilonWord64$fEpsilonWord32$fEpsilonWord16$fEpsilonWord8 $fEpsilonWord$fEpsilonInt64$fEpsilonInt32$fEpsilonInt16 $fEpsilonInt8$fEpsilonInteger $fEpsilonInt$fEpsilonFloat$fEpsilonDoubleComplex:+realPartimagPartmkPolarcispolar magnitudephase$fBoundedMeetSemiLatticeComplex$fBoundedJoinSemiLatticeComplex$fMeetSemiLatticeComplex$fJoinSemiLatticeComplex$fLowerBoundedFieldComplex$fUpperBoundedFieldComplex$fInvolutiveRingComplex$fExpFieldComplex$fFieldComplex$fIntegralDomainComplex$fEpsilonComplex$fMetricComplexa$fNormedComplexa$fFromIntegralComplexb$fDivisiveComplex$fMultiplicativeComplex$fDistributiveComplex$fSubtractiveComplex$fAdditiveComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1Complex$fFunctorComplex$fFoldableComplex$fTraversableComplex FromRational fromRational FromRatio fromRatio ToRationalToRatiotoRatioRatio:% toRationalfromBaseRational fromRational'reducegcd$fFromIntegralRatiob $fOrdRatio $fEqRatio$fMeetSemiLatticeRatio$fJoinSemiLatticeRatio$fEpsilonRatio$fMetricRatioRatio$fNormedRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fIntegralDomainRatio$fDistributiveRatio$fDivisiveRatio$fMultiplicativeRatio$fSubtractiveRatio$fAdditiveRatio$fToRatioWord64Integer$fToRatioWord32Integer$fToRatioWord16Integer$fToRatioWord8Integer$fToRatioWordInteger$fToRatioInt64Integer$fToRatioInt32Integer$fToRatioInt16Integer$fToRatioInt8Integer$fToRatioNaturalInteger$fToRatioIntegerInteger$fToRatioIntInteger$fToRatioRatioInteger$fToRatioRatioInteger0$fToRatioFloatInteger$fToRatioDoubleInteger$fFromRatioRatioInteger$fFromRatioRatioInteger0$fFromRatioFloatInteger$fFromRatioDoubleInteger$fFromRationalRatio$fFromRationalFloat$fFromRationalDouble $fShowRatioPairPair'$fMetricPairPair$fNormedPairPair$fFromRatioPairb$fFromIntegralPairb$fBoundedMeetSemiLatticePair$fBoundedJoinSemiLatticePair$fMeetSemiLatticePair$fJoinSemiLatticePair$fDivisiveActionPair$fMultiplicativeActionPair$fSubtractiveActionPair$fAdditiveActionPair$fLowerBoundedFieldPair$fUpperBoundedFieldPair$fExpFieldPair$fIntegralDomainPair $fFieldPair$fDistributivePair $fMetricPaira $fEpsilonPair $fNormedPaira $fSignedPair$fIntegralPair$fDivisivePair$fMultiplicativePair$fSubtractivePair$fAdditivePair $fBoundedPair $fMonoidPair$fSemigroupPair$fTraversablePair$fFoldablePair $fMonadPair$fApplicativePair $fShow1Pair $fEq1Pair $fFunctorPair $fShowPair$fEqPair $fGenericPairLogFieldlogField logToLogField fromLogFieldlogFromLogFieldpow accurateSumaccurateProduct$fSignedLogField$fUpperBoundedFieldLogField$fIntegralDomainLogField$fLowerBoundedFieldLogField$fFieldLogField$fEpsilonLogField$fMeetSemiLatticeLogField$fJoinSemiLatticeLogField$fToRatioLogFieldb$fFromRatioLogFieldb$fToIntegralLogFieldb$fFromIntegralLogFieldb$fExpFieldLogField$fDistributiveLogField$fDivisiveLogField$fMultiplicativeLogField$fSubtractiveLogField$fAdditiveLogField$fShowLogField $fEqLogField $fOrdLogField$fReadLogField$fDataLogField$fGenericLogField$fGeneric1LogField$fFunctorLogField$fFoldableLogField$fTraversableLogFieldWrapped unWrapped$fMetricWrappedWrapped$fNormedWrappedWrapped$fToRatioWrappedb$fFromRatioWrappedb$fToIntegralWrappedb$fFromIntegralWrappedb$fQuotientFieldWrappedWrapped $fShowWrapped $fEqWrapped $fOrdWrapped$fMagmaWrapped$fIdempotentWrapped$fAdditiveWrapped$fSubtractiveWrapped$fMultiplicativeWrapped$fDivisiveWrapped$fDistributiveWrapped$fIntegralDomainWrapped$fInvolutiveRingWrapped$fStarSemiringWrapped$fKleeneAlgebraWrapped$fFieldWrapped$fExpFieldWrapped$fTrigFieldWrapped$fIntegralWrapped$fSignedWrapped$fMeetSemiLatticeWrapped$fJoinSemiLatticeWrapped$fEpsilonWrapped$fUpperBoundedFieldWrapped$fLowerBoundedFieldWrappedNumHaskException errorMessage$fExceptionNumHaskException$fShowNumHaskExceptionPositive unPositivepositive positive_$fMetricaPositive$fNormedaPositive$fBoundedPositive$fUpperBoundedFieldPositive$fQuotientFieldPositivePositive$fSubtractivePositive$fShowPositive $fEqPositive $fOrdPositive$fAdditivePositive$fMultiplicativePositive$fDivisivePositive$fDistributivePositive$fIntegralDomainPositive$fFieldPositive$fExpFieldPositive$fTrigFieldPositive$fIntegralPositive$fSignedPositive$fJoinSemiLatticePositive$fMeetSemiLatticePositive$fEpsilonPositiveGHC.Numsignum Data.FoldableFoldableData.Traversable TraversableGCDConstraintsGHC.ShowShowghc-prim GHC.TypesDouble