NE%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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 { | } ~              NoneB`9 Minus () is reserved for where both the left and right cancellative laws hold. This then implies that the AdditiveGroup is also Abelian.Syntactic unary negation - substituting "negate a" for "-a" in code - is hard-coded in the language to assume a Num instance. So, for example, using ''-a = zero - a' for the second rule below doesn't work. Ha - a = zero negate a = zero - a negate a + a = zero a + negate a = zeroNon-commutative right minus a `plus` negate a = zeroNon-commutative left minus negate a `plus` a = zero>Additive is commutative, unital and associative under addition Ezero + a == a a + zero == a (a + b) + c == a + (b + c) a + b == b + aIdempotent magma for addition. a `plus` a == a Invertible magma for addition. " a " A: negate a " A&law is true by construction in Haskell Commutative magma for addition. a `plus` b == b `plus` a Associative magma for addition. .(a `plus` b) `plus` c == a `plus` (b `plus` c) Unital magma for addition. %zero `plus` a == a a `plus` zero == aD is used as the operator for the additive magma to distinguish from , which, by convention, implies commutativity " a,b " A: a `plus` b " A&law is true by construction in Haskell^sum definition avoiding a clash with the Sum monoid in base fixme: fit in with the Sum monoid     6666SafeB`J CAn Abelian Group is associative, unital, invertible and commutative-A Group is associative, unital and invertibleA Loop is unital and invertible9A CMonoidal Magma is commutative, associative and unital.+A Monoidal Magma is associative and unital.An Idempotent Magma  a " a = aAn Invertible Magma " a " T: inv a " T&law is true by construction in HaskellA Commutative Magma  a " b = b " aAn Associative Magma (a " b) " c = a " (b " c)A Unital Magma unit " a = a a " unit = aA  -https://en.wikipedia.org/wiki/Magma_(algebra)Magma is a tuple (T,") consisting of a type a, anda function (") :: T -> T -> T&The mathematical laws for a magma are:2" is defined for all possible pairs of type T, and7" is closed in the set of all possible values of type Tor, more tersly, " a, b " T: a " b " TFThese laws are true by construction in haskell: the type signature of magma. and the above mathematical laws are synonyms.see 8http://chris-taylor.github.io/blog/2013/02/25/xor-trick/NoneB`]c Divide () is reserved for where both the left and right cancellative laws hold. This then implies that the MultiplicativeGroup is also Abelian. Aa / a = one recip a = one / a recip a * a = one a * recip a = oneNon-commutative right divide a `times` recip a = oneNon-commutative left divide recip a `times` a = oneJMultiplicative is commutative, associative and unital under multiplication Cone * a == a a * one == a (a * b) * c == a * (b * c) a * b == b * a$Idempotent magma for multiplication. a `times` a == a$Invertible magma for multiplication. " a " A: recip a " A&law is true by construction in Haskell%Commutative magma for multiplication. a `times` b == b `times` a%Associative magma for multiplication. 2(a `times` b) `times` c == a `times` (b `times` c) Unital magma for multiplication. %one `times` a == a a `times` one == aJ is used as the operator for the multiplicative magam to distinguish from , which, by convention, implies commutativity " a,b " A: a `times` b " A&law is true by construction in Haskellgproduct definition avoiding a clash with the Product monoid in base fixme: fit in with Product in base7777NoneB``$Distribution (and annihilation) laws [a * (b + c) == a * b + a * c (a + b) * c == a * c + b * c a * zero == zero zero * a == zeroNone;=>?B`f element by element division a ./. a == singleton one !element by element multiplication e(a .*. b) .*. c == a .*. (b .*. c) singleton one .*. a = a a .*. singelton one = a a .*. b == b .*. aelement by element subtraction a .-. a = singleton zeroelement by element addition S(a .+. b) .+. c == a .+. (b .+. c) zero .+. a = a a .+. zero = a a .+. b == b .+. a             7 767None;=B`zInvolutive 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". KleeneAlgebra aa `times` x + x = a ==> star a `times` x + x = x x `times` a + x = a ==> x `times` star a + x = x StarSemiring star a = one + a `times` star aICRing is a Ring with Multiplicative Commutation. It arises often due to 9 being defined as a multiplicative commutative operation.Ring A Ring consists of a set equipped with two binary operations that generalize the arithmetic operations of addition and multiplication; it is an abelian group with a second binary operation that is associative, is distributive over the abelian group operation, and has an identity element.:Summary of the laws inherited from the ring super-classes: szero + 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 `times` a == a a `times` one == a (a `times` b) `times` c == a `times` (b `times` c) a `times` (b + c) == a `times` b + a `times` c (a + b) `times` c == a `times` c + b `times` c a `times` zero == zero zero `times` a == zeroSemiring  NoneB`$V+fromInteger is the most problematic of the Num class operators. Particularly heinous, it is assumed that any number type can be constructed from an Integer, so that the broad classes of objects that are composed of multiple elements is avoided in haskell.XKtoInteger is kept separate from Integral to help with compatability issues.Z Integral laws /b == zero || b * (a `div` b) + (a `mod` b) == aa coercion of Zs fromIntegral a == ad/raise a number to a non-negative integral powerVWXYZ^_[\`]abcdeZ[\]^_`XYVWabcdeVWXYZ[\]^_`[7\7None *7;=>?B`yTrigonometric Field`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.Pquotient fields explode constraints if they allow for polymorphic integral types Ra - one < floor a <= a <= ceiling a < a + one round a == floor (a + one/(one+one))}fixme: had to redefine Signed operators here because of the Field import in Metric, itself due to Complex being defined thereA hyperbolic field class Ysqrt . (**2) == identity log . exp == identity for +ive b, a != 0,1: a ** logBase a b "H bTA Field is a Ring plus additive invertible and multiplicative invertible operations.<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 = oneDA Semifield is chosen here to be a Field without an Additive InverseOtodo: work out boundings for complex as it stands now, complex is different eg $one / (zero :: Complex Float) == nan!todo: bottom is here somewhere???!$  None7;=>?B`ftodo: This should probably be split off into some sort of alternative Equality logic, but to what end?1distance 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 &&WL1 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.z 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?).-todo: is utf perfectly acceptable these days?4 None;=>?B`  Fractional6 in base splits into fromRatio and MultiplicativeGrouptoRatio is equivalent to Real in base. coercion of s fromRational a == afixme: use coerce is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor. 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.         None,;=>?BFST`Ͱ Igeneralised outer product 3a><b + c><b == (a+c) >< b a><b + a><c == a >< (b+c)6todo: work out why these laws down't apply > a *. (b> c)== (a<b) .* c > (a> b).* c == a *. (b<c)representation synthesisNtensorial typeO4the inner product of a representable over a semiring 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)QzBanach (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 == aUDivision Module Laws ?nearZero a || a ./ one == a b == zero || a ./ b == recip b *. aXMultiplicative Module 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[Subtraction Module Laws `(a + b) .- c == a + (b .- c) (a + b) .- c == (a .- c) + b a .- zero == a a .- b == negate b +. a^Additive Module Laws Y(a + b) .+ c == a + (b .+ c) (a + b) .+ c == (a .+ c) + b a .+ zero == a a .+ b == b +. aIKJLMNOPQRSTUVWXYZ[\]^_`^_`[\]XYZUVWQRSTOPNIJKLMIJKLMOPQRSTUVWXYZ[\]^_` J8N8P8V7W7Y7Z7\6]6_6`6 Safe;=>?B`ՐazThis class could also be called replicate. Looking forward, however, it may be useful to consider a Representable such as *VectorThing a = Vector a | Single a | Zeroand then ,singleton a = Single a singleton zero = Zeroshort-circuiting an expensive computation. As the class action then doesn't actually involve replication, it would be mis-named.ababab None 13456;=>?BK` c&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.dKforms a complex number from its real and imaginary rectangular components.e+Extracts the real part of a complex number.f0Extracts the imaginary part of a complex number.hh t# is a complex value with magnitude 1 and phase t (modulo 2*).i The function i 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.j.The nonnegative magnitude of a complex number.k,The phase of a complex number, in the range (-, ]2. If the magnitude is zero, then so is the phase.l!todo: bottom is here somewhere??? cdefghijk cdef~}|{zyxwvutsrqponmlghijkcdd6NoneB`     VWXYZ^_[\`]abcde  IKJLMNOPQRSTUVWXYZ[\]^_`cdNone36BK`Monoid under multiplication.-getProduct (Product 3 <> Product 4 <> mempty)12Monoid under addition.!getSum (Sum 1 <> Sum 2 <> mempty)3None&'13456;<=>?BK`%9Module : 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 k 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  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 $ 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.{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)EConstructor which assumes the argument is already in the log-domain.Semantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogField == exp . logFromLogField6Return 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): 'LogField (p ** m) == LogField 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): 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.O(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): <LogField . accurateProduct == accurateProduct . map LogField8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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 {     S b E 6    m ~ ^ N > . | } ~        &numhask-0.2.3.1-5X1V1rZSUVsE9M1b0C2H1iNumHask.Algebra.AdditiveNumHask.Algebra.MagmaNumHask.Algebra.MultiplicativeNumHask.Algebra.DistributionNumHask.Algebra.BasisNumHask.Algebra.RingNumHask.Algebra.IntegralNumHask.Algebra.FieldNumHask.Algebra.MetricNumHask.Algebra.RationalNumHask.Algebra.ModuleNumHask.Algebra.SingletonNumHask.Data.Complex NumHask.DataNumHask.Data.LogFieldNumHask.Algebra AdditiveGroup-AdditiveRightCancellative-~AdditiveLeftCancellative~-Additive+AdditiveIdempotentAdditiveInvertiblenegateAdditiveCommutativeAdditiveAssociativeAdditiveUnitalzero AdditiveMagmaplussumsubtract$fAdditiveMagmaWord64$fAdditiveMagmaWord32$fAdditiveMagmaWord16$fAdditiveMagmaWord8$fAdditiveMagmaWord$fAdditiveMagmaInt64$fAdditiveMagmaInt32$fAdditiveMagmaInt16$fAdditiveMagmaInt8$fAdditiveMagmaNatural$fAdditiveMagmaComplex$fAdditiveMagmaBool$fAdditiveMagmaInteger$fAdditiveMagmaInt$fAdditiveMagmaFloat$fAdditiveMagmaDouble$fAdditiveUnitalWord64$fAdditiveUnitalWord32$fAdditiveUnitalWord16$fAdditiveUnitalWord8$fAdditiveUnitalWord$fAdditiveUnitalInt64$fAdditiveUnitalInt32$fAdditiveUnitalInt16$fAdditiveUnitalInt8$fAdditiveUnitalNatural$fAdditiveUnitalComplex$fAdditiveUnitalBool$fAdditiveUnitalInteger$fAdditiveUnitalInt$fAdditiveUnitalFloat$fAdditiveUnitalDouble$fAdditiveAssociativeWord64$fAdditiveAssociativeWord32$fAdditiveAssociativeWord16$fAdditiveAssociativeWord8$fAdditiveAssociativeWord$fAdditiveAssociativeInt64$fAdditiveAssociativeInt32$fAdditiveAssociativeInt16$fAdditiveAssociativeInt8$fAdditiveAssociativeNatural$fAdditiveAssociativeComplex$fAdditiveAssociativeBool$fAdditiveAssociativeInteger$fAdditiveAssociativeInt$fAdditiveAssociativeFloat$fAdditiveAssociativeDouble$fAdditiveCommutativeWord64$fAdditiveCommutativeWord32$fAdditiveCommutativeWord16$fAdditiveCommutativeWord8$fAdditiveCommutativeWord$fAdditiveCommutativeInt64$fAdditiveCommutativeInt32$fAdditiveCommutativeInt16$fAdditiveCommutativeInt8$fAdditiveCommutativeNatural$fAdditiveCommutativeComplex$fAdditiveCommutativeBool$fAdditiveCommutativeInteger$fAdditiveCommutativeInt$fAdditiveCommutativeFloat$fAdditiveCommutativeDouble$fAdditiveInvertibleWord64$fAdditiveInvertibleWord32$fAdditiveInvertibleWord16$fAdditiveInvertibleWord8$fAdditiveInvertibleWord$fAdditiveInvertibleInt64$fAdditiveInvertibleInt32$fAdditiveInvertibleInt16$fAdditiveInvertibleInt8$fAdditiveInvertibleComplex$fAdditiveInvertibleBool$fAdditiveInvertibleInteger$fAdditiveInvertibleInt$fAdditiveInvertibleFloat$fAdditiveInvertibleDouble$fAdditiveIdempotentBool$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveNatural$fAdditiveComplex$fAdditiveBool$fAdditiveInteger $fAdditiveInt$fAdditiveFloat$fAdditiveDouble$fAdditiveGroupWord64$fAdditiveGroupWord32$fAdditiveGroupWord16$fAdditiveGroupWord8$fAdditiveGroupWord$fAdditiveGroupInt64$fAdditiveGroupInt32$fAdditiveGroupInt16$fAdditiveGroupInt8$fAdditiveGroupComplex$fAdditiveGroupInteger$fAdditiveGroupInt$fAdditiveGroupFloat$fAdditiveGroupDoubleAbelianGroupLoop CMonoidalMonoidal Idempotent Invertibleinv Commutative AssociativeUnitalunitMagma⊕ groupSwapMultiplicativeGroup/MultiplicativeRightCancellative/~MultiplicativeLeftCancellative~/Multiplicative*MultiplicativeIdempotentMultiplicativeInvertiblerecipMultiplicativeCommutativeMultiplicativeAssociativeMultiplicativeUnitaloneMultiplicativeMagmatimesproduct$fMultiplicativeMagmaWord64$fMultiplicativeMagmaWord32$fMultiplicativeMagmaWord16$fMultiplicativeMagmaWord8$fMultiplicativeMagmaWord$fMultiplicativeMagmaInt64$fMultiplicativeMagmaInt32$fMultiplicativeMagmaInt16$fMultiplicativeMagmaInt8$fMultiplicativeMagmaNatural$fMultiplicativeMagmaComplex$fMultiplicativeMagmaBool$fMultiplicativeMagmaInteger$fMultiplicativeMagmaInt$fMultiplicativeMagmaFloat$fMultiplicativeMagmaDouble$fMultiplicativeUnitalWord64$fMultiplicativeUnitalWord32$fMultiplicativeUnitalWord16$fMultiplicativeUnitalWord8$fMultiplicativeUnitalWord$fMultiplicativeUnitalInt64$fMultiplicativeUnitalInt32$fMultiplicativeUnitalInt16$fMultiplicativeUnitalInt8$fMultiplicativeUnitalNatural$fMultiplicativeUnitalComplex$fMultiplicativeUnitalBool$fMultiplicativeUnitalInteger$fMultiplicativeUnitalInt$fMultiplicativeUnitalFloat$fMultiplicativeUnitalDouble!$fMultiplicativeAssociativeWord64!$fMultiplicativeAssociativeWord32!$fMultiplicativeAssociativeWord16 $fMultiplicativeAssociativeWord8$fMultiplicativeAssociativeWord $fMultiplicativeAssociativeInt64 $fMultiplicativeAssociativeInt32 $fMultiplicativeAssociativeInt16$fMultiplicativeAssociativeInt8"$fMultiplicativeAssociativeNatural"$fMultiplicativeAssociativeComplex$fMultiplicativeAssociativeBool"$fMultiplicativeAssociativeInteger$fMultiplicativeAssociativeInt $fMultiplicativeAssociativeFloat!$fMultiplicativeAssociativeDouble!$fMultiplicativeCommutativeWord64!$fMultiplicativeCommutativeWord32!$fMultiplicativeCommutativeWord16 $fMultiplicativeCommutativeWord8$fMultiplicativeCommutativeWord $fMultiplicativeCommutativeInt64 $fMultiplicativeCommutativeInt32 $fMultiplicativeCommutativeInt16$fMultiplicativeCommutativeInt8"$fMultiplicativeCommutativeNatural"$fMultiplicativeCommutativeComplex$fMultiplicativeCommutativeBool"$fMultiplicativeCommutativeInteger$fMultiplicativeCommutativeInt $fMultiplicativeCommutativeFloat!$fMultiplicativeCommutativeDouble!$fMultiplicativeInvertibleComplex$fMultiplicativeInvertibleFloat $fMultiplicativeInvertibleDouble$fMultiplicativeIdempotentBool$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeComplex$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble$fMultiplicativeGroupComplex$fMultiplicativeGroupFloat$fMultiplicativeGroupDouble Distribution$fDistributionWord64$fDistributionWord32$fDistributionWord16$fDistributionWord8$fDistributionWord$fDistributionInt64$fDistributionInt32$fDistributionInt16$fDistributionInt8$fDistributionNatural$fDistributionComplex$fDistributionBool$fDistributionInteger$fDistributionInt$fDistributionFloat$fDistributionDoubleMultiplicativeGroupBasis./.MultiplicativeBasis.*.AdditiveGroupBasis.-. AdditiveBasis.+.InvolutiveRingadj KleeneAlgebra StarSemiringstarplus'CRingRingSemiring$fSemiringWord64$fSemiringWord32$fSemiringWord16$fSemiringWord8$fSemiringWord$fSemiringInt64$fSemiringInt32$fSemiringInt16$fSemiringInt8$fSemiringNatural$fSemiringComplex$fSemiringBool$fSemiringInteger $fSemiringInt$fSemiringFloat$fSemiringDouble $fRingWord64 $fRingWord32 $fRingWord16 $fRingWord8 $fRingWord $fRingInt64 $fRingInt32 $fRingInt16 $fRingInt8 $fRingComplex $fRingInteger $fRingInt $fRingFloat $fRingDouble $fCRingWord64 $fCRingWord32 $fCRingWord16 $fCRingWord8 $fCRingWord $fCRingInt64 $fCRingInt32 $fCRingInt16 $fCRingInt8$fCRingComplex$fCRingInteger $fCRingInt $fCRingFloat $fCRingDouble$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingComplex$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDouble FromInteger fromInteger ToInteger toIntegerIntegraldivmoddivModquotremquotRem fromIntegralevenodd^^^$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralNatural$fIntegralInteger $fIntegralInt$fToIntegerWord64$fToIntegerWord32$fToIntegerWord16$fToIntegerWord8$fToIntegerWord$fToIntegerInt64$fToIntegerInt32$fToIntegerInt16$fToIntegerInt8$fToIntegerNatural$fToIntegerInteger$fToIntegerInt$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerInteger$fFromIntegerInt$fFromIntegerFloat$fFromIntegerDouble TrigFieldpisincostanasinacosatansinhcoshtanhasinhacoshatanh BoundedFieldLowerBoundedField negInfinityUpperBoundedFieldinfinitynan QuotientFieldproperFractionroundceilingfloorExpFieldexploglogBase**sqrtField Semifield$fSemifieldComplex$fSemifieldFloat$fSemifieldDouble$fFieldComplex $fFieldFloat $fFieldDouble$fExpFieldFloat$fExpFieldDouble$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedFieldComplex$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat$fBoundedFielda$fTrigFieldFloat$fTrigFieldDouble$fExpFieldComplexEpsilonnearZero aboutEqualpositive veryPositive veryNegativeMetric distanceL1 distanceL2 distanceLpNormednormL1normL2normLpSignedsignabs≈$fSignedWord64$fSignedWord32$fSignedWord16 $fSignedWord8 $fSignedWord $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8$fSignedNatural$fSignedInteger $fSignedInt $fSignedFloat$fSignedDouble$fNormedWord64Word64$fNormedWord32Word32$fNormedWord16Word16$fNormedWord8Word8$fNormedWordWord$fNormedInt64Int64$fNormedInt32Int32$fNormedInt16Int16$fNormedInt8Int8$fNormedNaturalNatural$fNormedComplexa$fNormedIntegerInteger$fNormedIntInt$fNormedFloatFloat$fNormedDoubleDouble$fMetricWord64Word64$fMetricWord32Word32$fMetricWord16Word16$fMetricWord8Word8$fMetricWordWord$fMetricInt64Int64$fMetricInt32Int32$fMetricInt16Int16$fMetricInt8Int8$fMetricNaturalNatural$fMetricComplexa$fMetricIntegerInteger$fMetricIntInt$fMetricFloatFloat$fMetricDoubleDouble$fEpsilonWord64$fEpsilonWord32$fEpsilonWord16$fEpsilonWord8 $fEpsilonWord$fEpsilonInt64$fEpsilonInt32$fEpsilonInt16 $fEpsilonInt8$fEpsilonComplex$fEpsilonInteger $fEpsilonInt$fEpsilonFloat$fEpsilonDouble FromRatio fromRatioToRatiotoRatioRationalRatio:% fromRationalreducegcd$fFromIntegerRatio$fEpsilonRatio$fMetricRatioRatio$fNormedRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fSemifieldRatio$fInvolutiveRingRatio $fCRingRatio $fRingRatio$fSemiringRatio$fDistributionRatio$fMultiplicativeGroupRatio$fMultiplicativeRatio$fMultiplicativeInvertibleRatio $fMultiplicativeCommutativeRatio $fMultiplicativeAssociativeRatio$fMultiplicativeUnitalRatio$fMultiplicativeMagmaRatio$fAdditiveGroupRatio$fAdditiveRatio$fAdditiveInvertibleRatio$fAdditiveCommutativeRatio$fAdditiveAssociativeRatio$fAdditiveUnitalRatio$fAdditiveMagmaRatio $fOrdRatio $fEqRatio$fToRatioWord64$fToRatioWord32$fToRatioWord16$fToRatioWord8 $fToRatioWord$fToRatioInt64$fToRatioInt32$fToRatioInt16 $fToRatioInt8$fToRatioRatio$fToRatioNatural$fToRatioInteger $fToRatioInt$fToRatioFloat$fToRatioDouble$fToRatioRatio0$fFromRatioFloat$fFromRatioDouble$fFromRatioRatio $fShowRatio TensorProduct><outer timesleft timesrightHilbert<.>Banach normalizeL1 normalizeL2 normalizeLpMultiplicativeGroupModule.//.MultiplicativeModule.**.AdditiveGroupModule.--.AdditiveModule.++. Singleton singletonComplex:+realPartimagPartmkPolarcispolar magnitudephase $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1Complex$fFunctorComplex$fFoldableComplex$fTraversableComplexProduct getProductSumgetSum $fMonoidSum$fSemigroupSum$fAdditiveGroupSum $fAdditiveSum$fAdditiveCommutativeSum$fAdditiveInvertibleSum$fAdditiveAssociativeSum$fAdditiveUnitalSum$fAdditiveMagmaSum $fMonadSum$fApplicativeSum$fMonoidProduct$fSemigroupProduct$fMultiplicativeGroupProduct$fMultiplicativeProduct"$fMultiplicativeCommutativeProduct!$fMultiplicativeInvertibleProduct"$fMultiplicativeAssociativeProduct$fMultiplicativeUnitalProduct$fMultiplicativeMagmaProduct$fMonadProduct$fApplicativeProduct$fEqSum$fOrdSum $fReadSum $fShowSum $fBoundedSum $fGenericSum $fGeneric1Sum $fFunctorSum $fEqProduct $fOrdProduct $fReadProduct $fShowProduct$fBoundedProduct$fGenericProduct$fGeneric1Product$fFunctorProductLogFieldlogField logToLogField fromLogFieldlogFromLogFieldpow accurateSumaccurateProduct$fEpsilonLogField$fToRatioLogField$fFromRatioLogField$fToIntegerLogField$fFromIntegerLogField$fDistributionLogField$fMultiplicativeGroupLogField)$fMultiplicativeRightCancellativeLogField($fMultiplicativeLeftCancellativeLogField$fMultiplicativeLogField"$fMultiplicativeInvertibleLogField#$fMultiplicativeCommutativeLogField#$fMultiplicativeAssociativeLogField$fMultiplicativeUnitalLogField$fMultiplicativeMagmaLogField$fAdditiveLogField$fAdditiveCommutativeLogField$fAdditiveAssociativeLogField$fAdditiveUnitalLogField$fAdditiveMagmaLogField$fShowLogField $fEqLogField $fOrdLogField$fReadLogField$fDataLogField$fGenericLogField$fGeneric1LogField$fFunctorLogField$fFoldableLogField$fTraversableLogFieldbaseGHC.NumsignumfromBaseRational TensorRep Data.FoldableFoldableData.Traversable TraversableGHC.ShowShowghc-prim GHC.TypesDouble