h&nY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                             Safe-Inferrednumhaskor )https://en.wikipedia.org/wiki/Subtraction Subtraction\a -> a - a == zero\a -> negate a == zero - a\a -> negate a + a == zero\a -> a + negate a == zeronegate 1-11 - 2-1numhaskor &https://en.wikipedia.org/wiki/AdditionAddition4For practical reasons, we begin the class tree with . Starting with  and  , or using  and  from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.\a -> zero + a == a\a -> a + zero == a$\a b c -> (a + b) + c == a + (b + c)\a b -> a + b == b + aBy convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative addition seems a bit dogmatic.zero + 111 + 12numhaskCompute the sum of a . sum [0..10]55numhask"Compute the accumulating sum of a .accsum [0..10][0,1,3,6,10,15,21,28,36,45,55]66 Safe-InferredC numhaskAn  +https://en.wikipedia.org/wiki/Abelian_group Abelian Group is an Associative, Unital, Invertible and Commutative Magma . In other words, it is a Commutative Groupnumhask9An Idempotent Magma is a magma where every element is  )https://en.wikipedia.org/wiki/Idempotence Idempotent.  a E a = anumhask#An Absorbing is a Magma with an /https://en.wikipedia.org/wiki/Absorbing_elementAbsorbing Element a E absorb = absorbnumhaskA  1https://en.wikipedia.org/wiki/Group_(mathematics)Group2 is a Associative, Unital and Invertible Magma.numhaskAn Invertible Magma 0D a,b D T: inv a E (a E b) = b = (b E a) E inv anumhask>A Commutative Magma is a Magma where the binary operation is  2https://en.wikipedia.org/wiki/Commutative_property commutative.  a E b = b E anumhaskAn Associative Magma (a E b) E c = a E (b E c)numhask%A Unital Magma is a magma with an  .https://en.wikipedia.org/wiki/Identity_elementidentity element (the unit). unit E a = a a E unit = anumhaskA  -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, D a, b D T: a E b D TThese laws are true by construction in haskell: the type signature of . and the above mathematical laws are synonyms.  3 Safe-Inferrednumhaskor 4https://en.wikipedia.org/wiki/Division_(mathematics)DivisionThough unusual, the term Divisive usefully fits in with the grammer of other classes and avoids name clashes that occur with some popular libraries.+\(a :: Double) -> a / a ~= one || a == zero1\(a :: Double) -> recip a ~= one / a || a == zero1\(a :: Double) -> recip a * a ~= one || a == zero1\(a :: Double) -> a * recip a ~= one || a == zero recip 2.00.51 / 20.5numhaskor ,https://en.wikipedia.org/wiki/MultiplicationMultiplication4For practical reasons, we begin the class tree with  and . Starting with  and  , or using  and  from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.\a -> one * a == a\a -> a * one == a$\a b c -> (a * b) * c == a * (b * c)By convention, (*) is regarded as not necessarily commutative, but this is not universal, and the introduction of another symbol which means commutative multiplication seems a bit dogmatic.one * 222 * 36numhaskCompute the product of a .product [1..5]120numhask&Compute the accumulating product of a .accproduct [1..5][1,2,6,24,120]77 Safe-Inferred&pnumhaskInvolutive 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".numhaskA  ,https://en.wikipedia.org/wiki/Kleene_algebraKleene Algebra- is a Star Semiring with idempotent addition. a * x + x = a ==> star a * x + x = x x * a + x = a ==> x * star a + x = xnumhaskA  5https://en.wikipedia.org/wiki/Semiring#Star_semirings StarSemiring is a semiring with an additional unary operator (star) satisfying:  \a -> star a == one + a * star anumhaskA  0https://en.wikipedia.org/wiki/Ring_(mathematics)Ring% is an abelian group under addition (, , , %) and monoidal under multiplication (, 6), and where multiplication distributes over addition. \a -> zero + a == a \a -> a + zero == a \a b c -> (a + b) + c == a + (b + c) \a b -> a + b == b + a \a -> a - a == zero \a -> negate a == zero - a \a -> negate a + a == zero \a -> a + negate a == zero \a -> one * a == a \a -> a * one == a \a b c -> (a * b) * c == a * (b * c) \a b c -> a * (b + c) == a * b + a * c \a b c -> (a + b) * c == a * c + b * c \a -> zero * a == zero \a -> a * zero == zeronumhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive&\a b c -> a * (b + c) == a * b + a * c&\a b c -> (a + b) * c == a * c + b * c\a -> zero * a == zero\a -> a * zero == zeroThe sneaking in of the  /https://en.wikipedia.org/wiki/Absorbing_element Absorption laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.numhask Defining  requires adding the multiplicative unital to itself. In other words, the concept of  is a Ring one.two2   Safe-Inferred.) numhaskA 2https://en.wikipedia.org/wiki/Module_(mathematics)Module a .* one == a (a + b) .* c == (a .* c) + (b .* c) c *. (a + b) == (c *. a) + (c *. b) a .* zero == zero a .* b == b *. anumhaskDivisive ActionnumhaskMultiplicative ActionnumhaskSubtractive ActionnumhaskAdditive Actionnumhaskflipped additive action (+.) == flip (.+)numhaskright scalar subtraction (-.) == (+.) . negatenumhaskflipped multiplicative action (*.) == flip (.*)numhaskright scalar division (/.) == (*.) . recip  7766667  Safe-Inferred;<0qnumhask;A small number, especially useful for approximate equality.numhaskare we near enough?nearZero (epsilon :: Double)TruenumhaskApproximate equality#aboutEqual zero (epsilon :: Double)Truenumhask/Something that has a magnitude and a direction.numhaskConvert between a "co-ordinated" or "higher-kinded" number and representations of an angle. Typically thought of as polar co-ordinate conversion.See 5https://en.wikipedia.org/wiki/Polar_coordinate_systemPolar coordinate system (ray . angle == basis norm (ray x) == onenumhaskNorm is a slight generalisation of Signed. The class has the same shape but allows the codomain to be different to the domain. \a -> norm a >= zero \a -> norm zero == zero \a -> a == norm a .* basis a \a -> norm (basis a) == onenorm (-0.5 :: Double) :: Double0.5 basis (-0.5 :: Double) :: Double-1.0numhaskor length, or ||v||numhaskor direction, or v-hatnumhask from base is not an operator name in numhask and is replaced by . Compare with % where there is a change in codomain.\a -> abs a * sign a ~= aabs zero == zero, so any value for sign zero is ok. We choose lawful neutral:sign zero == zeroTrueabs (-1)1 sign (-1)-1numhaskDistance, which combines the Subtractive notion of difference, with Norm. distance a b >= zero distance a a == zero distance a b .* basis (a - b) == a - bnumhask!Convert from a number to a Polar.numhaskConvert from a Polar to a (coordinated aka higher-kinded) number.numhaskAbout equal operator."(1.0 + epsilon) ~= (1.0 :: Double)Truenumhask0numhask1e-6numhask1e-144  Safe-Inferred ./6numhask is special in two ways:numeric integral literals (like "42") are interpreted specifically as "fromInteger (42 :: GHC.Num.Integer)". The prelude version is used as default (or whatever fromInteger is in scope if RebindableSyntax is set).The default rules in  https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-750004.3 haskell2010 specify that constraints on  need to be in a form C v(, where v is a Num or a subclass of Num.So a type synonym of `type FromInteger a = FromIntegral a Integer` doesn't work well with type defaulting; hence the need for a separate class.numhask"Polymorphic version of fromInteger fromIntegral a == anumhasktoIntegral is kept separate from Integral to help with compatability issues. toIntegral a == anumhask/An Integral is anything that satisfies the law:7\a b -> b == zero || b * (a `div` b) + (a `mod` b) == a 3 `divMod` 2(1,1)(-3) `divMod` 2(-2,1)(-3) `quotRem` 2(-1,-1)numhaskeven 2Truenumhaskodd 3Truenumhaskraise a number to an  power2 ^^ 38.0 2 ^^ (-2)0.25numhaskraise a number to an 9 powerNote: This differs from (^) found in prelude which is a partial function (it errors on negative integrals). This monomorphic version is provided to help reduce ambiguous type noise in common usages of this sign.2 ^ 38.02 ^ (-2)0.257788  Safe-Inferred <ASnumhaskTrigonometric Field The list of laws is quite long: >https://en.wikipedia.org/wiki/List_of_trigonometric_identitiestrigonometric identitiesnumhaskConversion from a  to a See 0https://en.wikipedia.org/wiki/Field_of_fractionsField of fractions 3\a -> a - one < floor a <= a <= ceiling a < a + one(\a -> a - one < fromIntegral (floor a :: Int) && fromIntegral (floor a :: Int) <= a && a <= fromIntegral (ceiling a :: Int) && fromIntegral (ceiling a :: Int) <= a + one) :: Double -> Bool3\a -> (round a :: Int) ~= (floor (a + half) :: Int)numhaskround to the nearest integralExact ties are managed by rounding down ties if the whole component is even.round (1.5 :: Double) :: Int2round (2.5 :: Double) :: Int2numhask%supply the next upper whole component ceiling (1.001 :: Double) :: Int2numhask)supply the previous lower whole componentfloor (1.001 :: Double) :: Int1numhask*supply the whole component closest to zerofloor (-1.001 :: Double) :: Int-2"truncate (-1.001 :: Double) :: Int-1numhaskA hyperbolic field class'\a -> a < zero || (sqrt . (**2)) a == a$\a -> a < zero || (log . exp) a ~= a\a b -> (b < zero) || a <= zero || a == 1 || abs (a ** logBase a b - b) < 10 * epsilonnumhasklog to the base of logBase 2 82.9999999999999996numhask square rootsqrt 42.0numhaskA  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.=A summary of the rules inherited from super-classes of Field: zero + 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 / a == one || a == zero recip a == one / a || a == zero recip a * a == one || a == zero a * recip a == one || a == zeronumhaskinfinity is defined for any .one / zero + infinityInfinity infinity + 1Infinitynumhasknan is defined as zero/zerobut note the (social) law:nan == zero / zeroFalsenumhasknegative infinitynegInfinity + infinityNaNnumhaskA  is a ; because it requires addition, multiplication and division.half :: Double0.5    Safe-Inferred.G numhaskLattices 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 == xnumhaskThe combination of two semi lattices makes a lattice if the absorption law holds: see  +http://en.wikipedia.org/wiki/Absorption_lawAbsorption Law and ,http://en.wikipedia.org/wiki/Lattice_(order)Lattice /Absorption: a \/ (a /\ b) == a /\ (a \/ b) == anumhask.A algebraic structure with element meets: See (http://en.wikipedia.org/wiki/Semilattice Semilattice Associativity: x /\ (y /\ z) == (x /\ y) /\ z Commutativity: x /\ y == y /\ x Idempotency: x /\ x == xnumhask.A algebraic structure with element joins: See (http://en.wikipedia.org/wiki/Semilattice Semilattice Associativity: x \/ (y \/ z) == (x \/ y) \/ z Commutativity: x \/ y == y \/ x Idempotency: x \/ x == xnumhask>The partial ordering induced by the join-semilattice structurenumhask>The partial ordering induced by the join-semilattice structurenumhask>The partial ordering induced by the meet-semilattice structurenumhask>The partial ordering induced by the meet-semilattice structure  6566  Safe-Inferred .689:;I9numhask.Complex numbers have real and imaginary parts.The  and ( instances traverse the real part first.numhask+Extracts the real part of a complex number.numhask0Extracts the imaginary part of a complex number.numhask8A euclidean-style norm is strong convention for Complex.numhaskforms a complex number from its real and imaginary rectangular components.6 Safe-Inferred ./Pnumhask$fromRational is special in two ways:numeric decimal literals (like "53.66") are interpreted as exactly "fromRational (53.66 :: GHC.Real.Ratio Integer)". The prelude version, GHC.Real.fromRational is used as default (or whatever is in scope if RebindableSyntax is set).The default rules in  https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-750004.3 haskell2010 specify that contraints on  need to be in a form C v(, where v is a Num or a subclass of Num.So a type synonym of `type FromRational a = FromRatio a Integer` doesn't work well with type defaulting; hence the need for a separate class.numhask$( in base splits into fromRatio and Field-fromRatio (5 :% 2 :: Ratio Integer) :: Double2.5numhasktoRatio is equivalent to *2 in base, but is polymorphic in the Integral type.-toRatio (3.1415927 :: Float) :: Ratio Integer13176795 :% 4194304numhaskA rational numbernumhaskHas a zero denominatornumhask normalises a ratio by dividing both numerator and denominator by their greatest common divisor. reduce 72 606 :% 5)\a b -> reduce a b == a :% b || b == zeronumhask 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 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)2Note: Since for signed fixed-width integer types,   < 09, the result may be negative if one of the arguments is & (and necessarily is if the other is 0 or ) for such types. gcd 72 6012 > > Safe-InferredQ numhaskA numhask exception.__ Safe-Inferred.Q>>_>_ Safe-Inferred.SnumhaskRebindableSyntax splats this, and I'm not sure where it exists in GHC land  ! "#$%&'()*+,-./0fkmi`labcehngdj1KMNL234BE56789:;?@AGFOPQRSTUVWXYZ[\]^_opqrstuvwxyz{|}~;  ! "#$%&'()*+,-./0labcehngdj1KMNL234BE56789:?@AGFOPQRSTUVWXYZ[\]^prsw}~0fklmabcehin`gdjopqrstuvwxyz{|}~ !"#$% &' &( )* +, +- !. !/ !0 1 2 3 4#56#57 !8 !9 !: !; <= >? @A BC BD !E !F !G !H !I !J !K L M#5N OP @Q !R !S TU#5V WX @Y OZ @[ \] <^ !_   ! !#`a !b#`c#`d#`e#`fghigjk lm#`n @o#`p#`q rs#`t lu lv#`w rx ry#`z#`{#`| } ~   ) ) ) ) ) ) ) ) ) ) ) )                                               r W W W W  O O O O O O O O O O O O O @       \ \ \ \ \ \ \ \ & & & & & & & & & & & & & & & & & & & & & & & & & & &   + + T ! ! ! ! ! ! ! ! ! !     #5#5#5#5#5#5#5#5#5#5                                                                                                                                                                                                                                                                                                                                                                     ! !#`#`                                                                                                                                       'numhask-0.10.1.1-5se1IUyAn3UALQnNUDpTp7NumHask.PreludeNumHask.Data.RationalNumHask.ExceptionNumHask.Algebra.AdditiveNumHask.Algebra.GroupNumHask.Algebra.MultiplicativeNumHask.Algebra.RingNumHask.Algebra.ModuleNumHask.Algebra.MetricNumHask.Data.IntegralNumHask.Algebra.FieldNumHask.Algebra.LatticeNumHask.Data.Complex AssociativeUnitalData.Semigroup Semigroup Data.MonoidMonoid Data.FoldableFoldableData.Traversable TraversableAdditiveNumHask.Algebra Commutative InvertibleRingGHC.EnumminBoundNumHaskbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$enumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=>>=>>fmapreturnControl.Monad.Failfail Data.String fromStringGHC.Real realToFracGHC.ExtsfromList fromListN<>memptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalMonadFunctorGHC.NumNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow MonadFail Applicative GHC.TypesBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGTtraverse sequenceAsequencemapM writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileGHC.IO.ExceptionioErrorGHC.IOFilePathIOError userError GHC.ExceptionthrowtoListnullminimummaximumlengthfoldr1foldr'foldrfoldl1foldl'foldlfoldMap'foldMapfoldelem traverse_ sequence_ sequenceA_ornotElemmsum minimumBy maximumBymapM_for_forM_foldrMfoldlMfind concatMapconcatasumanyandall Data.OldListwordsunwordsunlineslines Text.Readreadsreadeither readsPrecreadList readParenlexText.ParserCombinators.ReadPReadS significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatlcmtoEnumsuccpredfromEnummaxBoundShowS showsPrecshowListshowshows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletaketailsplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookuplastiterateinithead dropWhiledropcyclebreak!! Data.Maybemaybe Data.Functor<$>uncurrycurrysignum<$<*untilidflipconstasTypeOf=<<.$!GHC.Err undefinederrorWithoutStackTraceerror GHC.NaturalNatS#NatJ#&&not||/=<<=>comparemaxmin Subtractivenegate-+zerosumaccsum $fAdditiveFUN$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveNatural$fAdditiveBool$fAdditiveInteger $fAdditiveInt$fAdditiveFloat$fAdditiveDouble$fSubtractiveFUN$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveNatural$fSubtractiveInteger$fSubtractiveInt$fSubtractiveFloat$fSubtractiveDouble AbelianGroup Idempotent AbsorbingabsorbGroupinvunitMagma⊕ $fMagmaFUN $fUnitalFUN$fAssociativeFUN$fCommutativeFUN$fInvertibleFUN$fGroupa$fAbsorbingFUN$fIdempotentFUN$fAbelianGroupaDivisiverecip/Multiplicative*oneproduct accproduct$fMultiplicativeFUN$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble $fDivisiveFUN$fDivisiveFloat$fDivisiveDoubleInvolutiveRingadj KleeneAlgebra StarSemiringstarplus Distributivetwo$fDistributiveFUN$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble$fRinga$fStarSemiringFUN$fKleeneAlgebraFUN$fInvolutiveRingFUN$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleDivisiveAction./MultiplicativeAction.*SubtractiveAction.-AdditiveAction.++.-.*./.EpsilonepsilonnearZero aboutEqualPolar magnitude direction DirectionanglerayNormnormbasisSignedsignabsdistancepolarcoord~=$fSignedWord64$fSignedWord32$fSignedWord16 $fSignedWord8 $fSignedWord $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8$fSignedNatural$fSignedInteger $fSignedInt $fSignedFloat$fSignedDouble$fNormWord64Word64$fNormWord32Word32$fNormWord16Word16$fNormWord8Word8$fNormWordWord$fNormInt64Int64$fNormInt32Int32$fNormInt16Int16$fNormInt8Int8$fNormNaturalNatural$fNormIntegerInteger $fNormIntInt$fNormFloatFloat$fNormDoubleDouble$fEpsilonWord64$fEpsilonWord32$fEpsilonWord16$fEpsilonWord8 $fEpsilonWord$fEpsilonInt64$fEpsilonInt32$fEpsilonInt16 $fEpsilonInt8$fEpsilonInteger $fEpsilonInt$fEpsilonFloat$fEpsilonDouble $fEqPolar $fShowPolar$fGenericPolar FromInteger fromInteger FromIntegral fromIntegral ToIntegral toIntegralIntegraldivmoddivModquotremquotRemevenodd^^^ $fIntegralFUN$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralNatural$fIntegralInteger $fIntegralInt$fToIntegralWord64Word64$fToIntegralWord32Word32$fToIntegralWord16Word16$fToIntegralWord8Word8$fToIntegralWordWord$fToIntegralInt64Int64$fToIntegralInt32Int32$fToIntegralInt16Int16$fToIntegralInt8Int8$fToIntegralNaturalNatural$fToIntegralWord64Int$fToIntegralWord32Int$fToIntegralWord16Int$fToIntegralWord8Int$fToIntegralWordInt$fToIntegralInt64Int$fToIntegralInt32Int$fToIntegralInt16Int$fToIntegralInt8Int$fToIntegralNaturalInt$fToIntegralIntegerInt$fToIntegralIntInt$fToIntegralWord64Integer$fToIntegralWord32Integer$fToIntegralWord16Integer$fToIntegralWord8Integer$fToIntegralWordInteger$fToIntegralInt64Integer$fToIntegralInt32Integer$fToIntegralInt16Integer$fToIntegralInt8Integer$fToIntegralNaturalInteger$fToIntegralIntInteger$fToIntegralIntegerInteger$fFromIntegralWord64Word64$fFromIntegralWord32Word32$fFromIntegralWord16Word16$fFromIntegralWord8Word8$fFromIntegralWordWord$fFromIntegralInt64Int64$fFromIntegralInt32Int32$fFromIntegralInt16Int16$fFromIntegralInt8Int8$fFromIntegralNaturalNatural$fFromIntegralWord64Int$fFromIntegralWord32Int$fFromIntegralWord16Int$fFromIntegralWord8Int$fFromIntegralWordInt$fFromIntegralInt64Int$fFromIntegralInt32Int$fFromIntegralInt16Int$fFromIntegralInt8Int$fFromIntegralNaturalInt$fFromIntegralIntegerInt$fFromIntegralIntInt$fFromIntegralFloatInt$fFromIntegralDoubleInt$fFromIntegralWord64Integer$fFromIntegralWord32Integer$fFromIntegralWord16Integer$fFromIntegralWord8Integer$fFromIntegralWordInteger$fFromIntegralInt64Integer$fFromIntegralInt32Integer$fFromIntegralInt16Integer$fFromIntegralInt8Integer$fFromIntegralNaturalInteger$fFromIntegralIntegerInteger$fFromIntegralIntInteger$fFromIntegralFloatInteger$fFromIntegralDoubleInteger$fFromIntegralFUNb$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerInteger$fFromIntegerInt$fFromIntegerFloat$fFromIntegerDouble TrigFieldpisincostanasinacosatanatan2sinhcoshtanhasinhacoshatanh QuotientFieldproperFractionroundceilingfloortruncateExpFieldexplog**logBasesqrtFieldinfinitynan negInfinityhalf $fFieldFUN $fFieldFloat $fFieldDouble $fExpFieldFUN$fExpFieldFloat$fExpFieldDouble$fQuotientFieldFUNFUN$fQuotientFieldDoubleInt$fQuotientFieldFloatInt$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fTrigFieldFUN$fTrigFieldFloat$fTrigFieldDoubleBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomMeetSemiLattice/\JoinSemiLattice\/joinLeq<\meetLeq