h$vk       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                    None!Ynumhaskor )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 .66 Safe-Inferred>( 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.  3None-numhaskor 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 .77None>4numhaskInvolutive 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  None,6CnumhaskA 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 Action  77776666 None ,-9>?;numhask 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: /b == zero || b * (a `div` b) + (a `mod` b) == anumhaskeven 2Truenumhaskodd 3Truenumhaskraise a number to an  powernumhaskraise a number to an D 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.7788 None 9>?C numhaskTrigonometric Field numhaskNegative infinity. numhaskF numhask,A meet-semilattice with an identity element   for  . Identity: x /\ top == x numhask,A join-semilattice with an identity element   for  . Identity: x \/ bottom == x numhask.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 == x numhask.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 == x numhask>The partial ordering induced by the join-semilattice structure numhask>The partial ordering induced by the meet-semilattice structure  6 5 None8>L numhask;A small number, especially useful for approximate equality. numhask/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) == 1 numhaskNorm is a slight generalisation of Signed. The class has the same shape but allows the codomain to be different to the domain. norm a >= zero norm zero == zero a == norm a .* basis a norm (basis a) == one numhask from base is not an operator name in numhask and is replaced by  . Compare with  $ where there is a change in codomain abs a * sign a == a numhaskDistance, which combines the Subtractive notion of difference, with Norm. distance a b >= zero distance a a == zero distance a b .* basis (a - b) == a - b numhask!Convert from a number to a Polar. numhaskConvert from a Polar to a (coordinated aka higher-kinded) number. numhask About equal. numhask0 numhask1e-6 numhask1e-14   4 None ,35678>N. numhask.Complex numbers have real and imaginary parts.The  and ( instances traverse the real part first. numhaskforms 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. numhask8A euclidean-style norm is strong convention for Complex.   6None,-9>?U  numhask$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.5 numhasktoRatio is equivalent to +2 in base, but is polymorphic in the Integral type. -toRatio (3.1415927 :: Float) :: Ratio Integer13176795 :% 4194304 numhaskA rational number numhask  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 = 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. M M None 35678>c6 numhaskA LogField is just a  % with a special interpretation. The   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: logField (p + q) == logField p + logField q logField (p * q) == logField p * logField qPerforming 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 LogFields addition requires crossing the exp/log boundary twice; with a LogField and a B 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! 1That is, true up-to underflow and floating point fuzziness. Which is, of course, the whole point of this module. numhaskConstructor 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) numhaskConstructor 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 . logFromLogField numhask6Return the log-domain value itself without conversion. numhaskO(1). Compute powers in the log-domain; that is, the following equivalence holds (modulo underflow and all that): 'LogField (p ** m) == LogField p `pow` m numhaskO(n)&. Compute the sum of a finite list of  s, 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. numhaskO(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): ?c numhaskWrapped numeric instances   Safe-Inferredd numhaskA numhask exception.  None>?e  numhaskWrapper for positive numbers. Note that the constructor is not exported. numhaskmaybe construct a  numhaskConstruct a Positive, throwing an error if the input is negative.  None,e7M None,f numhaskRebindableSyntax splats this, and I'm not sure where it exists in GHC land !"  # $%&'() *+,-./012 3456789:;<=>?@mqABlCnDEFGHIJKopLvtuMNOPQRSTUVWrsXYZ[\]^_`abcdefghijkwx{yz~|}      J!"  # $%&'() *+,-./012 3456789:;<=>?@mqABlCnDEFGHIKopLvtuMNOPQRSTUVWrsXYZ[\]^_`abcdefghijkwx{yz~|} !"#$%&!'(!')!*+!*,!"-!".!/!0!1!2$34$35!"6!"7!"8!"9!:;!<=!>?!@A!BC!BD!"E!"F!"G!"H!IJ!"K!"L!"M!"N!O!P$3Q!RS!>T!"U!"V!WX$3Y!Z[!>\!R]!>^!_`!ab!:c!<d!"e!!!fg!fh!fi!fj!fk!lm!no!pq!"!"!rs$tu$tv$tw$tx$ty!z{!z|!z}!z~!I!$t!>!$t$t!!!!!!!$t$t!f!f!f!f!f!f!f!f!f!f!f!f$t$t!l$t!!$t$t$t!!$t!!$t$t$t!f!f!f!f!f!f!f!f!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!p!r!!!!!@!@!@!@!@!@!@!@!@!@!@!@!@!@!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!f!n!n!n!n!n!n!l!l!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!4!!!!!!!!!R!R!R!R!R!R!R!R!R!R!R!R!R!R!R!R!R!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!>!!!!!!!!!!!_!'!'!'!'!'!'!'!'!'!'!'!'!'!'!'!'!!!!!!!!!!!!!!!!*!*!*!!!!!!!!!!!W!!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!"!!!!I!$3$3$3$3$3$3$3$3$3$3                                                                                                                                                                                                                        &numhask-0.7.1.0-L0knaGsPb6PJAGlPoK4bjYNumHask.PreludeNumHask.Data.RationalNumHask.ExceptionNumHask.Algebra.AdditiveNumHask.Algebra.GroupNumHask.Algebra.MultiplicativeNumHask.Algebra.RingNumHask.Algebra.ModuleNumHask.Data.IntegralNumHask.Algebra.FieldNumHask.Algebra.LatticeNumHask.Analysis.MetricNumHask.Data.ComplexNumHask.Data.LogFieldNumHask.Data.WrappedNumHask.Data.Positive AssociativeUnitalData.Semigroup Semigroup Data.MonoidMonoid Data.FoldableFoldableAdditiveData.Traversable TraversableGHC.EnumminBoundNumHask.Algebra.MultiplicationproductNumHaskbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwise$enumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=>>=>>fmapreturnControl.Monad.Failfail Data.String fromStringGHC.Real realToFrac Control.MonadguardGHC.ExtsfromList fromListN<>memptymappendmconcat GHC.NaturalNatS#join<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalMonadFunctorGHC.NumNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative GHC.GenericsGenericGeneric1Datatype ConstructorSelector GHC.TypeNatsKnownNat GHC.TypeLits KnownSymbolGHC.OverloadedLabelsIsLabel GHC.RecordsHasField GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeIntegerNatural GHC.MaybeMaybeOrderingRational GHC.Stable StablePtrIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtr Data.EitherEitherType ConstraintV1U1K1M1:+::*::.:Rec0D1C1S1URecNatSymbolCmpNat Coercible GHC.StaticPtr StaticPtrGHC.Stack.Types CallStackD#FalseF#NothingJustTrueLeftRightLTEQGTPrefixIInfixILeftAssociativeRightAssociativeNotAssociativeMetaDataMetaConsMetaSelGHC.IO.Handle.TypesHandleGHC.STST GHC.Conc.SyncforkOnWithUnmaskforkIOWithUnmaskforkOnControl.ConcurrentforkOSThreadId"async-2.2.2-KekkAJkpoh6Az2hBaGvAEhControl.Concurrent.Async concurrentlyrace_racelink2linkwaitBothwaitEitherCancel waitEither_ waitEitherwaitEitherCatchCancelwaitEitherCatch waitAnyCancelwaitAnywaitAnyCatchCancel waitAnyCatch cancelWithcancelpoll waitCatchwait withAsyncOnwithAsyncBound withAsyncasyncOn asyncBoundasync asyncThreadIdAsyncrunConcurrently Concurrently Data.Complex conjugate Data.VoidvacuousabsurdVoidoption mtimesDefaultdiffcycle1 WrappedMonoid getOptionOptionthreadWaitWriteSTMthreadWaitReadSTMthreadWaitWritethreadWaitReadrunInUnboundThreadrunInBoundThreadisCurrentThreadBoundforkOSWithUnmask forkFinallyrtsSupportsBoundThreadsControl.Concurrent.ChanwriteList2ChangetChanContentsdupChanreadChan writeChannewChanChanControl.Concurrent.QSem signalQSemwaitQSemnewQSemQSemControl.Concurrent.QSemN signalQSemN waitQSemNnewQSemNQSemNData.Bifunctorsecondfirstbimap BifunctorData.List.NonEmptynonEmptyGHC.ExecutionStackshowStackTrace getStackTraceGHC.ExecutionStack.Internal sourceColumn sourceLineSrcLocsrcLoc functionName objectNameLocationControl.Monad.IO.ClassliftIOMonadIO fromLabelgetFieldSystem.EnvironmentgetArgs System.Exit exitSuccess exitFailureexitWithmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMfoldMapDefault fmapDefault mapAccumR mapAccumLforMforsequencemapM sequenceAtraverseControl.Applicativeoptional getZipListZipListData.Functor.Identity runIdentityIdentity System.IOwithFileGHC.IO.Handle.FDopenFilestderrstdin GHC.Conc.IO threadDelayControl.Concurrent.MVar mkWeakMVaraddMVarFinalizermodifyMVarMaskedmodifyMVarMasked_ modifyMVar modifyMVar_withMVarMaskedwithMVarswapMVar GHC.StackwithFrozenCallStack callStackControl.ExceptionallowInterruptcatchesHandlerControl.Monad.ST.ImpfixSTControl.Exception.BasebracketOnErrorbracket_finallybracket onExceptiontryJusttry mapException handleJusthandle catchJustPatternMatchFail RecSelError RecConError RecUpdError NoMethodError TypeErrorNonTerminationNestedAtomicallycatchSTMthrowSTMorElseretry atomicallymkWeakThreadIdthreadCapabilityyield myThreadId killThreadsetNumCapabilitiesgetNumCapabilitiesforkIOSTMGHC.IO.ExceptionioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededCompactionFailedAssertionFailedSomeAsyncException UserInterrupt ThreadKilled HeapOverflow StackOverflowAsyncExceptionUndefinedElementIndexOutOfBoundsArrayException ExitFailure ExitSuccessExitCodestdoutGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingState interruptiblecatchFilePathMaskedUninterruptibleMaskedInterruptibleUnmasked MaskingState IOException GHC.ExceptionprettyCallStack prettySrcLocthrow ErrorCallErrorCallWithLocationGHC.Exception.Type SomeExceptiondisplayException fromException toException ExceptionRatioZeroDenominatorDenormal DivideByZeroLossOfPrecision UnderflowOverflowArithException Data.TypeablegcasteqTcasttypeReptypeOfTypeRepData.Functor.ConstgetConstConstfindnotElem minimumBy maximumByallanyorand concatMapconcatmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_foldlMfoldrMminimummaximumelemlengthnulltoListfoldl'foldlfoldr'foldrfoldMapfoldgetFirstFirstgetLastLastgetApApData.Semigroup.Internal stimesMonoidstimesIdempotentgetDualDualappEndoEndogetAllAllgetAnyAnygetAltAltunK1unM1R1L1unComp1Comp1 isNewtype packageName moduleName datatypeName conIsRecord conFixityconNameInfixPrefixFixityFixityI AssociativityselDecidedStrictnessselSourceStrictnessselSourceUnpackednessselNametofromMeta someSymbolVal someNatVal symbolValnatVal SomeSymbolSomeNat Data.OldListunfoldrsortBysort permutations subsequencestailsinitsgroupBygroupgenericReplicategenericSplitAt genericDrop genericTake genericLength transpose intercalate intersperse isPrefixOf Data.CharisLetter digitToInt Text.Read readMaybe readEitherreads fromRightfromLeftisRightisLeftpartitionEithersrightsleftseitherData.Ord comparingDown Data.ProxyProxyControl.Category.idCategoryData.Type.Coercionrepr coerceWithCoercionData.Type.Equality gcastWithcastWithsymRefl:~: Foreign.PtrWordPtrIntPtr GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModeForeign.StorableStorablelog1mexplog1pexpexpm1log1pisIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix byteSwap64 byteSwap32 byteSwap16 GHC.UnicodetoTitletoUppertoLowerisLowerisUpperisPrint isControl isAlphaNumisAlpha isHexDigitisDigitisSpaceisAscii Data.BitstoIntegralSizedpopCountDefaulttestBitDefault bitDefaultpopCountrotateRrotateLshiftRshiftLisSignedbitSize bitSizeMaybetestBit complementBitclearBitsetBitbitzeroBitsrotateshift complementxor.|..&.BitscountTrailingZeroscountLeadingZeros finiteBitSize FiniteBitsintegralEnumFromThenTointegralEnumFromTointegralEnumFromThenintegralEnumFromgcdWord'gcdInt'lcm^^%^^^%^numericEnumFromThenTonumericEnumFromTonumericEnumFromThennumericEnumFrom denominator numerator% notANumber ratioPrec1 ratioPrecunderflowError overflowErrorratioZeroDenominatorError divZeroErrorboundedEnumFromThenboundedEnumFrommaxBoundfromEnumtoEnumpredsuccGHC.CharchrrunST intToDigitunzipzipWithreversebreaksplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanrscanl'scanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.Function&onfix Data.Functorvoid$><&><$>swapuncurrycurryGHC.MVar isEmptyMVar tryReadMVar tryPutMVar tryTakeMVarputMVarreadMVartakeMVarnewMVar newEmptyMVarMVarsignum GHC.Stack.CCScurrentCallStackasTypeOfuntilflipconstmaxIntminIntordapliftM5liftM4liftM3liftM2liftMwhen=<<liftA3liftA<**>stimessconcat<$<*liftA2manysome<|>empty Alternativemplusmzero MonadPlus:|NonEmpty getCallStack HasCallStackstimesIdempotentMonoidNatJ#compare<<=>maxmin/=&&||notbytestring-0.10.10.0Data.ByteString.Internal ByteStringcontainers-0.6.2.1Data.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Map.InternalMapData.Sequence.InternalSeqData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqforce$!!deepseqrnfNFData'hashable-1.3.0.0-1P2Y3eA5cTdB8Gcn7yS7qiData.Hashable.Class hashUsinghash hashWithSaltHashabletransformers-0.5.6.2Control.Monad.Trans.Classlift mtl-2.2.2Control.Monad.State.Classgetsmodifystateputget MonadStateControl.Monad.Reader.Classasksreaderlocalask MonadReaderControl.Monad.Error.Class catchError throwError MonadErrorControl.Monad.Trans.ExceptExceptTExcept runExcept mapExcept withExcept runExceptT mapExceptT withExceptTControl.Monad.Trans.ReaderReaderT runReaderTReader runReaderControl.Monad.Trans.State.LazyStateT runStateTStaterunState evalState execState withState evalStateT execStateT&protolude-0.3.0-4JWYLUjHdniIkiCsczdyJB ProtoludedieshowliftIO2liftIO1guardedAguardedpassthrowTothrowIOprintapplyNunsnocunconsmapidentityLText LByteStringProtolude.Debugwitness undefinednotImplementedtraceIdtraceM traceShowM traceShowId traceShowtraceIOtraceProtolude.Show putErrTextputLByteString putByteStringputLTextputTextputErrLnputStrLn hPutStrLnputStrhPutStrPrintProtolude.SafeatDefatMay foldl1May' foldl1May foldr1May maximumDef minimumDef maximumMay minimumMaylastDeflastMaytailSafetailDeftailMayinitSafeinitDefinitMayheadDefheadMayProtolude.PanicpanicfatalErrorMessage FatalErrorProtolude.MonadliftM2'liftM' concatMapMProtolude.ListlistordNubsortOnheadProtolude.FunctorforeachProtolude.ExceptionstryIOnotehushProtolude.Either maybeToEither maybeEmpty maybeToLeft maybeToRight rightToMaybe leftToMaybeProtolude.ConvertText toUtf8LazytoUtf8toS ConvertTextProtolude.Bool<&&>&&^<||>||^guardMifMunlessMwhenMboolProtolude.Base$!Protolude.ApplicativeliftAA2purereitherAorEmptyorAltthrowEcatchE text-1.2.3.2Data.Text.Encoding.ErrorUnicodeException OnDecodeErrorOnError strictDecode lenientDecodeignorereplaceData.Text.InternalTextData.Text.EncodingdecodeUtf8With decodeUtf8 decodeUtf8' encodeUtf8 Data.TextwordslinesunlinesunwordsData.Text.LazytoStrict fromStrict Data.Text.IOreadFile writeFile appendFileinteract getContentsgetLine stm-2.5.0.0Control.Monad.STMcheckpackData.Text.Showunpack Subtractivenegate-+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 CommutativeunitMagma⊕ $fMagma-> $fUnital->$fAssociative->$fCommutative->$fInvertible->$fGroupa $fAbsorbing->$fIdempotent->$fAbelianGroupaDivisiverecip/Multiplicative*one$fMultiplicative->$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble $fDivisive->$fDivisiveFloat$fDivisiveDoubleInvolutiveRingadj KleeneAlgebra StarSemiringstarplusRing Distributivetwo$fDistributive->$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble$fRinga$fStarSemiring->$fKleeneAlgebra->$fInvolutiveRing->$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleDivisiveAction.//.MultiplicativeAction.**.SubtractiveAction.--.AdditiveAction.++. FromInteger fromInteger FromIntegral fromIntegral ToIntegral toIntegralIntegraldivmoddivModquotremquotRemevenodd^^^ $fIntegral->$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$fFromIntegral->b$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerInteger$fFromIntegerInt$fFromIntegerFloat$fFromIntegerDouble TrigFieldpisincostanasinacosatanatan2sinhcoshtanhasinhacoshatanhLowerBoundedField negInfinityUpperBoundedFieldinfinitynan QuotientFieldproperFractionroundceilingfloortruncateExpFieldexploglogBase**sqrtFieldhalf $fField-> $fFieldFloat $fFieldDouble $fExpField->$fExpFieldFloat$fExpFieldDouble$fQuotientField->->$fQuotientFieldDoubleInt$fQuotientFieldFloatInt$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedField->$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedField->$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat $fTrigField->$fTrigFieldFloat$fTrigFieldDoubleBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomMeetSemiLattice/\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 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$fGenericPolarComplex:+realPartimagPart$fBoundedMeetSemiLatticeComplex$fBoundedJoinSemiLatticeComplex$fMeetSemiLatticeComplex$fJoinSemiLatticeComplex$fLowerBoundedFieldComplex$fUpperBoundedFieldComplex$fInvolutiveRingComplex$fExpFieldComplex$fFieldComplex$fEpsilonComplex$fDirectionComplexa$fNormComplexa$fFromIntegralComplexb$fDivisiveComplex$fMultiplicativeComplex$fDistributiveComplex$fSubtractiveComplex$fAdditiveComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1TYPEComplex$fFunctorComplex$fFoldableComplex$fTraversableComplex FromRational fromRational FromRatio fromRatioToRatiotoRatioRatio:%reducegcd$fFromIntegralRatiob$fEpsilonRatio$fMeetSemiLatticeRatio$fJoinSemiLatticeRatio$fNormRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fDistributiveRatio$fDivisiveRatio$fMultiplicativeRatio$fSubtractiveRatio$fAdditiveRatio $fOrdRatio $fEqRatio$fToRatioWord64Integer$fToRatioWord32Integer$fToRatioWord16Integer$fToRatioWord8Integer$fToRatioWordInteger$fToRatioInt64Integer$fToRatioInt32Integer$fToRatioInt16Integer$fToRatioInt8Integer$fToRatioNaturalInteger$fToRatioIntegerInteger$fToRatioIntInteger$fToRatioRatioInteger$fToRatioRatioInteger0$fToRatioFloatInteger$fToRatioDoubleInteger$fFromRatioRatioInteger$fFromRatioFloatInteger$fFromRatioDoubleInteger$fFromRationalRatio$fFromRationalFloat$fFromRationalDouble $fShowRatioLogFieldlogField logToLogField fromLogFieldlogFromLogFieldpow accurateSumaccurateProduct$fSignedLogField$fUpperBoundedFieldLogField$fLowerBoundedFieldLogField$fFieldLogField$fEpsilonLogField$fMeetSemiLatticeLogField$fJoinSemiLatticeLogField$fToRatioLogFieldb$fFromRatioLogFieldb$fToIntegralLogFieldb$fFromIntegralLogFieldb$fExpFieldLogField$fDistributiveLogField$fDivisiveLogField$fMultiplicativeLogField$fSubtractiveLogField$fAdditiveLogField$fShowLogField $fEqLogField $fOrdLogField$fReadLogField$fDataLogField$fGenericLogField$fGeneric1TYPELogField$fFunctorLogField$fFoldableLogField$fTraversableLogFieldWrapped unWrapped$fToRatioWrappedb$fFromRatioWrappedb$fToIntegralWrappedb$fFromIntegralWrappedb$fQuotientFieldWrappedWrapped $fShowWrapped $fEqWrapped $fOrdWrapped$fMagmaWrapped$fIdempotentWrapped$fAdditiveWrapped$fSubtractiveWrapped$fMultiplicativeWrapped$fDivisiveWrapped$fDistributiveWrapped $fRingWrapped$fInvolutiveRingWrapped$fStarSemiringWrapped$fKleeneAlgebraWrapped$fFieldWrapped$fExpFieldWrapped$fTrigFieldWrapped$fIntegralWrapped$fSignedWrapped$fMeetSemiLatticeWrapped$fJoinSemiLatticeWrapped$fBoundedJoinSemiLatticeWrapped$fBoundedMeetSemiLatticeWrapped$fEpsilonWrapped$fUpperBoundedFieldWrapped$fLowerBoundedFieldWrappedNumHaskException errorMessage$fExceptionNumHaskException$fShowNumHaskExceptionPositive positive_positive$fBoundedPositive$fUpperBoundedFieldPositive$fQuotientFieldPositivePositive$fSubtractivePositive$fShowPositive $fEqPositive $fOrdPositive$fAdditivePositive$fMultiplicativePositive$fDivisivePositive$fDistributivePositive$fFieldPositive$fExpFieldPositive$fTrigFieldPositive$fIntegralPositive$fSignedPositive$fJoinSemiLatticePositive$fMeetSemiLatticePositive$fEpsilonPositive ifThenElse'bifunctors-5.5.8-LF5Ini7YxQp9WPHhr303UEData.BiapplicativetraverseBiaWith sequenceBia traverseBiabiliftA3<<**>><<$>> Biapplicative<<**>>biliftA2bipure<<*>>#mmorph-1.1.3-Dmsr1l7Kr6T4kfaT7lOgT8Control.Monad.Morph|>==<|<|<>|>squash generalizeMFunctorhoistMMonadembed MonadTrans#random-1.2.0-7h4RyWOayRNDypmvRo2ybfSystem.Random.Stateful runSTGen_runSTGen applySTGen newSTGenM applyIOGen newIOGenMapplyAtomicGen newAtomicGenMrandomRMrandomM uniformListMwithMutableGen_withMutableGen splitGenM RandomGenMapplyRandomGenM AtomicGenM unAtomicGenM AtomicGen unAtomicGenIOGenMunIOGenMIOGenunIOGenSTGenMunSTGenMSTGenunSTGen System.RandomrandomIO randomRIO getStdRandom newStdGen getStdGen setStdGen genByteStringuniformRuniformRandomrandomsrandomRsrandomrandomRSystem.Random.InternaluniformFloatPositive01MuniformFloat01MuniformDoublePositive01MuniformDouble01MmkStdGen runStateGenST runStateGenT_ runStateGenT runStateGen_ runStateGenuniformByteStringMgenShortByteStringSTgenShortByteStringIO RandomGengenRangegenShortByteString genWord64R genWord32R genWord64 genWord32 genWord16genWord8splitnext StatefulGenuniformShortByteString uniformWord64 uniformWord32 uniformWord16 uniformWord8uniformWord32RuniformWord64R MutableGen FrozenGenthawGen freezeGen StateGenMStateGen unStateGenStdGenUniformuniformM UniformRange uniformRMData.Functor.ConstantConstant getConstant