!G       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneDb$66Safe=?Db=D )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+,./*-)Safe=?@ADb@@numhaskLA Isomorphism between two magmas an Isomorphism is a bijective HomomorphismBnumhask:A Homomorphism between two magmas law: forall a b. hom(a 5 b) = hom(a) 5 hom(b)?@ABCDEBCA@DE?NoneDbAnJLKMNOPMNOPJLKL7N7None >@ADHVbClpnumhask=a type class to represent an action on a higher-kinded number defghijklmnop pmnojklghidefe7f7h7i7k6l6n6o6None=?Db]qnumhaskInvolutive 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".snumhaskA  ,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 = xtnumhaskA  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 awnumhaskAn  -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. FIXME: write a rule for thisxnumhaskA  .https://en.wikipedia.org/wiki/Commutative_ringCommutative Ringn is a ring with a Commutative Multiplication operation. Recall that Addition is Commutative in all RingsynumhaskA  0https://en.wikipedia.org/wiki/Ring_(mathematics)Ring is an abelian group under addition and monoid under multiplication where multiplication distributes over addition. Alternatively, a ring is semiring where additive inverses existznumhaskA  &https://en.wikipedia.org/wiki/SemiringSemiring6 is a ring without, necessarily, negative elements.AFIXME: rule zero' = zero. Is this somehow expressible in haskell?{numhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive laws 9a * (b + c) == a * b + a * c (a * b) * c == a * c + b * c qrstuvwxyz{| {zyxwtuvsqr| None>@ADbc2numhaskA  2https://en.wikipedia.org/wiki/Module_(mathematics)Modulea over r a is a (Ring a), an abelian (Group r a) and an scalar-mult. (.*, *.) 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 -@ADHUVbinumhaskgeneralised outer product ia><b + c><b == (a+c) >< b a><b + a><c == a >< (b+c) a *. (b><c) == (a><b) .* c (a><b) .* c == a *. (b><c)numhaskgeneralised outer product ia><b + c><b == (a+c) >< b a><b + a><c == a >< (b+c) a *. (b><c) == (a><b) .* c (a><b) .* c == a *. (b><c)numhaskrepresentation synthesisnumhasktensorial type 88 None =?@ADXbkmLnumhaskelement 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=>?@ADHVby`numhaskghc 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=>?@ADXbk$numhaskTrigonometric Field%numhask`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 b4numhaskA  1https://en.wikipedia.org/wiki/Field_(mathematics)FieldZ is an Integral domain in which every non-zero element has a multiplicative inverse.<A summary of the rules 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 = one! !"#$%&'()-*+,./032145!4./0321()-*+,%&'#$ !"5None=?Db HnumhaskLattices with both boundsInumhask,A meet-semilattice with an identity element J for O. Identity: x /\ top == xKnumhask,A join-semilattice with an identity element L for Q. Identity: x \/ bottom == xMnumhaskWThe 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) == aNnumhask*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 == xPnumhask*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 == xRnumhask>The partial ordering induced by the join-semilattice structureSnumhask>The partial ordering induced by the meet-semilattice structure HIJKLMNOPQRS PQRNOSMKLIJHO6Q5None=?@ADbpnumhask1distance 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 and Banach$ 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.  6None>@ADSXbnumhask&the inner product: a distributive fold ba <.> b == b <.> a a <.> (b +c) == a <.> b + a <.> c a <.> (s *. b + c) == s * (a <.> b) + a <.> c (s0 *. a)  . (s1 *. b) == s0 * s1 * (a  . b)numhaskzBanach (with Norm) laws form rules around size and direction of a number, with a potential crossing into another codomain. 5a == singleton zero || normalizeL2 a *. normL2 a == a8NoneDb¢i)*+,-./012345?@ABCDEJLKMNOPdefghijklmnopqrstuvwxyz{| !"#$%&'()-*+,./032145HIJKLMNOPQRSNone,8=>?@ADHVXb$numhask"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=>?@ADHVbgK;numhaskLA 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=?@ADbfnumhaskModule : 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 4% with a special interpretation. The fk 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 g 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 P$ 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.gnumhask{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)hnumhaskEConstructor which assumes the argument is already in the log-domain.inumhaskSemantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogField == exp . logFromLogFieldjnumhask6Return the log-domain value itself without conversion.knumhaskO(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.13lnumhaskO(n)&. Compute the sum of a finite list of fws, 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.mnumhaskO(n)*. Compute the product of a finite list of fs, 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 LogFieldfghijklmfgihjlmkk8None =>?@ADIMbSafeDbMNone =>?@ADIMb !"#$%&'()*+,-./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 [ \ ] ^ _ `abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ $numhask-0.3.1-DKNm7NmQrrF1TQCSoCNk9INumHask.Data.RationalNumHask.Exception!NumHask.Algebra.Abstract.AdditiveNumHask.Algebra.Abstract.Group%NumHask.Algebra.Abstract.Homomorphism'NumHask.Algebra.Abstract.MultiplicativeNumHask.Algebra.Abstract.ActionNumHask.Algebra.Abstract.RingNumHask.Algebra.Abstract.Module&NumHask.Algebra.Abstract.TensorProductNumHask.Algebra.Linear.HadamardNumHask.Data.IntegralNumHask.Algebra.Abstract.Field NumHask.Algebra.Abstract.LatticeNumHask.Analysis.MetricNumHask.Data.ComplexNumHask.Analysis.BanachNumHask.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->$fAbelianGroupa AutomorphismIsoEndHomhomisoinvIso $fHom->->$fEnda $fIso->->$fAutomorphismaDivisiverecip/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 StarSemiringstarplusIntegralDomainCommutativeRingRingSemiring Distributivetwo$fDistributive->$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble $fSemiringa$fRinga$fCommutativeRinga$fIntegralDomain->$fIntegralDomainFloat$fIntegralDomainDouble$fStarSemiring->$fKleeneAlgebra->$fInvolutiveRing->$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleTensorProduct'outer' timesleft' timesright' TensorProduct><outer timesleft timesrightHadamardHadamardDivision./.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$fTraversableComplexHilbert<.>Banach normalizeL1 normalizeL2 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$fEpsilonPositive TensorRepGHC.Numsignum Data.FoldableFoldableData.Traversable TraversableGCDConstraintsGHC.ShowShowghc-prim GHC.TypesDouble