!<      !"#$%&'()*+,-./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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneDb!m66Safe=?Db9 (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 a/numhask>A Commutative Magma is a Magma where the binary operation is  2https://en.wikipedia.org/wiki/Commutative_property commutative. a magma b = b magma a0numhaskAn Associative Magma )(a magma b) magma c = a magma (b magma c)1numhask%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 = a3numhaskA  -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 4. and the above mathematical laws are synonyms. ()*+,-./01234 34120/*+-.),(Safe=?@ADb=?numhaskLA Isomorphism between two magmas an Isomorphism is a bijective HomomorphismAnumhask:A Homomorphism between two magmas law: forall a b. hom(a 4 b) = hom(a) 4 hom(b)>?@ABCDAB@?CD>NoneDb>!IKJLMNOLMNOIKJK7M7None >@ADHVb@onumhask=a type class to represent an action on a higher-kinded number cdefghijklmno olmnijkfghcded7e7g7h7j6k6m6n6None=?DbZpnumhaskInvolutive 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".rnumhaskA  ,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 = xsnumhaskA  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 avnumhaskAn  -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 thiswnumhaskA  .https://en.wikipedia.org/wiki/Commutative_ringCommutative Ringn is a ring with a Commutative Multiplication operation. Recall that Addition is Commutative in all RingsxnumhaskA  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 existynumhaskA  &https://en.wikipedia.org/wiki/SemiringSemiring6 is a ring without, necessarily, negative elements.@TODO: rule zero' = zero. Is this somehow expressible in haskell?znumhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive laws 9a * (b + c) == a * b + a * c (a * b) * c == a * c + b * c pqrstuvwxyz{ zyxwvsturpq{None>@ADb_numhaskA  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 -DHUVbc}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 type88 None =?@ADXbkgnumhaskelement by element division a ./. a == singleton onenumhask!element by element multiplication e(a .*. b) .*. c == a .*. (b .*. c) singleton one .*. a = a a .*. singelton one = a a .*. b == b .*. a77 NoneDbpcnumhask+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.numhaskKtoInteger is kept separate from Integral to help with compatability issues.numhask Integral laws /b == zero || b * (a `div` b) + (a `mod` b) == anumhask coercion of s fromIntegral a == anumhask/raise a number to a non-negative integral power77 None8@ADbanumhaskOtodo: work out boundings for complex as it stands now, complex is different eg $one / (zero :: Complex Float) == nanBinstance (UpperBoundedField a) => UpperBoundedField (Complex a)Trigonometric 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.numhaskPquotient 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 therenumhaskA 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)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" " None=?DbRnumhaskLattices with both boundsnumhask,A meet-semilattice with an identity element  for . Identity: x /\ top == xnumhask,A join-semilattice with an identity element  for . Identity: x \/ bottom == xnumhaskWThe 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) == anumhask*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 == xnumhask*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  !  !65None=?@ADbenumhask1distance 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 &&hnumhaskWL1 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.knumhaskz from base is not an operator replicated in numhask, being such a very silly name, and preferred is the much more obvious l. 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?).abcdefghijkmlnkmlhijefgabcdnn4None 24567=?@ADbnumhask&Complex numbers are an algebraic type.For a complex number z, m z# is a number with the magnitude of z8, but oriented in the positive real direction, whereas l 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>@ADSXb^numhask&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 == a8NoneDbj()*+,-./01234>?@ABCDIKJLMNOcdefghijklmnopqrstuvwxyz{  !None,=?@ADb(numhask Fractional( in base splits into fromRatio and FieldnumhasktoRatio is equivalent to Real in base.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.numhask coercion of s fromRational a == anumhaskfixme: use coercenumhask 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, m 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=>?@ADHVbg'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 5numhaskthe preferred patternNone 24567Db,numhaskModule : 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 O$ 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.-numhask{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).numhaskEConstructor which assumes the argument is already in the log-domain./numhaskSemantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogField == exp . logFromLogField0numhask6Return the log-domain value itself without conversion.1numhaskO(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.132numhaskO(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.3numhaskO(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 LogField,-./0123,-/.023118None =>?@ADIMbPQRPQRSafeDb klmklmNone =>?@ADIMbpqrstpqrst !"#$%&'()*+,-./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 xyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgghijklmnopqrstuvwxyz{|}~ &numhask-0.3.0.0-6WRgeQbTP4wKSUIUfjamJdNumHask.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.RationalNumHask.Data.PairNumHask.Data.LogFieldNumHask.Data.WrappedNumHask.Data.PositiveNumHask.Algebra.Abstractbase 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$fInvolutiveRingDoubleModule TensorProduct><outer timesleft timesrightHadamardHadamardDivision./.HadamardMultiplication.*. $fHadamardma FromInteger fromInteger ToInteger toIntegerIntegraldivmoddivModquotremquotRem fromIntegralevenodd^^^ $fIntegral->$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$fFromInteger-> TrigFieldpisincostanasinacosatansinhcoshtanhasinhacoshatanhLowerBoundedField negInfinityUpperBoundedFieldinfinitynanisNaN QuotientFieldproperFractionroundceilingfloortruncateExpFieldexploglogBase**sqrtFieldhalf $fFieldFloat $fFieldDouble$fExpFieldFloat$fExpFieldDouble$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat$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$fFromIntegerComplex$fDivisiveComplex$fMultiplicativeComplex$fDistributiveComplex$fSubtractiveComplex$fAdditiveComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1Complex$fFunctorComplex$fFoldableComplex$fTraversableComplexHilbert<.>Banach normalizeL1 normalizeL2 FromRatio fromRatioToRatiotoRatioRationalRatio:% fromRationalreducegcd$fFromIntegerRatio $fOrdRatio $fEqRatio$fMeetSemiLatticeRatio$fJoinSemiLatticeRatio$fEpsilonRatio$fMetricRatioRatio$fNormedRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fIntegralDomainRatio$fDistributiveRatio$fDivisiveRatio$fMultiplicativeRatio$fSubtractiveRatio$fAdditiveRatio$fToRatioWord64$fToRatioWord32$fToRatioWord16$fToRatioWord8 $fToRatioWord$fToRatioInt64$fToRatioInt32$fToRatioInt16 $fToRatioInt8$fToRatioRatio$fToRatioNatural$fToRatioInteger $fToRatioInt$fToRatioFloat$fToRatioDouble$fToRatioRatio0$fFromRatioFloat$fFromRatioDouble$fFromRatioRatio $fShowRatioPairPair'$fMetricPairPair$fNormedPairPair$fFromRatioPair$fFromIntegerPair$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$fToRatioLogField$fFromRatioLogField$fToIntegerLogField$fFromIntegerLogField$fExpFieldLogField$fDistributiveLogField$fDivisiveLogField$fMultiplicativeLogField$fSubtractiveLogField$fAdditiveLogField$fShowLogField $fEqLogField $fOrdLogField$fReadLogField$fDataLogField$fGenericLogField$fGeneric1LogField$fFunctorLogField$fFoldableLogField$fTraversableLogFieldWrapped unWrapped$fQuotientFieldWrappedWrapped $fShowWrapped $fEqWrapped $fOrdWrapped$fAdditiveWrapped$fSubtractiveWrapped$fMultiplicativeWrapped$fDivisiveWrapped$fDistributiveWrapped$fIntegralDomainWrapped$fFieldWrapped$fExpFieldWrapped$fTrigFieldWrapped$fIntegralWrapped$fSignedWrapped$fJoinSemiLatticeWrapped$fMeetSemiLatticeWrapped$fEpsilonWrapped$fUpperBoundedFieldWrapped$fLowerBoundedFieldWrapped$fToIntegerWrapped$fFromIntegerWrapped$fFromRatioWrapped$fToRatioWrappedNumHaskException 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 TraversableGCDConstraintsfromBaseRationalGHC.ShowShowghc-prim GHC.TypesDouble