Data.Semiring.Infinite

This module provides various "infinite" wrappers, which can provide a detectable infinity to an otherwise non-infinite type.

Documentation

class HasPositiveInfinity a where

A class for semirings with a concept of "infinity". It's important that this isn't regarded as the same as "bounded": x <+> positiveInfinity should probably equal positiveInfinity.

Minimal complete definition

positiveInfinity, isPositiveInfinity

Methods

positiveInfinity :: a

A positive infinite value

isPositiveInfinity :: a -> Bool

Test if a value is positive infinity.

Instances

HasPositiveInfinity Double

Methods

positiveInfinity :: Double

isPositiveInfinity :: Double -> Bool

HasPositiveInfinity Float

Methods

positiveInfinity :: Float

isPositiveInfinity :: Float -> Bool

HasPositiveInfinity CFloat

Methods

positiveInfinity :: CFloat

isPositiveInfinity :: CFloat -> Bool

HasPositiveInfinity CDouble

Methods

positiveInfinity :: CDouble

isPositiveInfinity :: CDouble -> Bool

HasPositiveInfinity (Infinite a)

Methods

positiveInfinity :: Infinite a

isPositiveInfinity :: Infinite a -> Bool

HasPositiveInfinity (PositiveInfinite a)

Methods

positiveInfinity :: PositiveInfinite a

isPositiveInfinity :: PositiveInfinite a -> Bool

class HasNegativeInfinity a where

A class for semirings with a concept of "negative infinity". It's important that this isn't regarded as the same as "bounded": x <+> negativeInfinity should probably equal negativeInfinity.

Minimal complete definition

negativeInfinity, isNegativeInfinity

Methods

negativeInfinity :: a

A negative infinite value

isNegativeInfinity :: a -> Bool

Test if a value is negative infinity.

Instances

HasNegativeInfinity Double

Methods

negativeInfinity :: Double

isNegativeInfinity :: Double -> Bool

HasNegativeInfinity Float

Methods

negativeInfinity :: Float

isNegativeInfinity :: Float -> Bool

HasNegativeInfinity CFloat

Methods

negativeInfinity :: CFloat

isNegativeInfinity :: CFloat -> Bool

HasNegativeInfinity CDouble

Methods

negativeInfinity :: CDouble

isNegativeInfinity :: CDouble -> Bool

HasNegativeInfinity (Infinite a)

Methods

negativeInfinity :: Infinite a

isNegativeInfinity :: Infinite a -> Bool

HasNegativeInfinity (NegativeInfinite a)

Methods

negativeInfinity :: NegativeInfinite a

isNegativeInfinity :: NegativeInfinite a -> Bool

data NegativeInfinite a

Adds negative infinity to a type. Useful for expressing detectable infinity in types like Integer, etc.

Constructors

NegativeInfinity

NegFinite !a

Instances

Functor NegativeInfinite

Methods

fmap :: (a -> b) -> NegativeInfinite a -> NegativeInfinite b

(<$) :: a -> NegativeInfinite b -> NegativeInfinite a

Applicative NegativeInfinite

Methods

pure :: a -> NegativeInfinite a

(<*>) :: NegativeInfinite (a -> b) -> NegativeInfinite a -> NegativeInfinite b

(*>) :: NegativeInfinite a -> NegativeInfinite b -> NegativeInfinite b

(<*) :: NegativeInfinite a -> NegativeInfinite b -> NegativeInfinite a

Foldable NegativeInfinite

Methods

fold :: Monoid m => NegativeInfinite m -> m

foldMap :: Monoid m => (a -> m) -> NegativeInfinite a -> m

foldr :: (a -> b -> b) -> b -> NegativeInfinite a -> b

foldr' :: (a -> b -> b) -> b -> NegativeInfinite a -> b

foldl :: (b -> a -> b) -> b -> NegativeInfinite a -> b

foldl' :: (b -> a -> b) -> b -> NegativeInfinite a -> b

foldr1 :: (a -> a -> a) -> NegativeInfinite a -> a

foldl1 :: (a -> a -> a) -> NegativeInfinite a -> a

toList :: NegativeInfinite a -> [a]

null :: NegativeInfinite a -> Bool

length :: NegativeInfinite a -> Int

elem :: Eq a => a -> NegativeInfinite a -> Bool

maximum :: Ord a => NegativeInfinite a -> a

minimum :: Ord a => NegativeInfinite a -> a

sum :: Num a => NegativeInfinite a -> a

product :: Num a => NegativeInfinite a -> a

Traversable NegativeInfinite

Methods

traverse :: Applicative f => (a -> f b) -> NegativeInfinite a -> f (NegativeInfinite b)

sequenceA :: Applicative f => NegativeInfinite (f a) -> f (NegativeInfinite a)

mapM :: Monad m => (a -> m b) -> NegativeInfinite a -> m (NegativeInfinite b)

sequence :: Monad m => NegativeInfinite (m a) -> m (NegativeInfinite a)

Generic1 NegativeInfinite

Associated Types

type Rep1 (NegativeInfinite :: * -> *) :: * -> *

Methods

from1 :: NegativeInfinite a -> Rep1 NegativeInfinite a

to1 :: Rep1 NegativeInfinite a -> NegativeInfinite a

Eq1 NegativeInfinite

Methods

liftEq :: (a -> b -> Bool) -> NegativeInfinite a -> NegativeInfinite b -> Bool

Ord1 NegativeInfinite

Methods

liftCompare :: (a -> b -> Ordering) -> NegativeInfinite a -> NegativeInfinite b -> Ordering

Read1 NegativeInfinite

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NegativeInfinite a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [NegativeInfinite a]

Show1 NegativeInfinite

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> NegativeInfinite a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [NegativeInfinite a] -> ShowS

Unbox a => Vector Vector (NegativeInfinite a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (NegativeInfinite a) -> m (Vector (NegativeInfinite a))

basicUnsafeThaw :: PrimMonad m => Vector (NegativeInfinite a) -> m (Mutable Vector (PrimState m) (NegativeInfinite a))

basicLength :: Vector (NegativeInfinite a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (NegativeInfinite a) -> Vector (NegativeInfinite a)

basicUnsafeIndexM :: Monad m => Vector (NegativeInfinite a) -> Int -> m (NegativeInfinite a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (NegativeInfinite a) -> Vector (NegativeInfinite a) -> m ()

elemseq :: Vector (NegativeInfinite a) -> NegativeInfinite a -> b -> b

Unbox a => MVector MVector (NegativeInfinite a)

Methods

basicLength :: MVector s (NegativeInfinite a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (NegativeInfinite a) -> MVector s (NegativeInfinite a)

basicOverlaps :: MVector s (NegativeInfinite a) -> MVector s (NegativeInfinite a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (NegativeInfinite a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> NegativeInfinite a -> m (MVector (PrimState m) (NegativeInfinite a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> Int -> m (NegativeInfinite a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> Int -> NegativeInfinite a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> NegativeInfinite a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> MVector (PrimState m) (NegativeInfinite a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> MVector (PrimState m) (NegativeInfinite a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (NegativeInfinite a) -> Int -> m (MVector (PrimState m) (NegativeInfinite a))

Bounded a => Bounded (NegativeInfinite a)

Methods

minBound :: NegativeInfinite a

maxBound :: NegativeInfinite a

(Enum a, Bounded a, Eq a) => Enum (NegativeInfinite a)

Methods

succ :: NegativeInfinite a -> NegativeInfinite a

pred :: NegativeInfinite a -> NegativeInfinite a

toEnum :: Int -> NegativeInfinite a

fromEnum :: NegativeInfinite a -> Int

enumFrom :: NegativeInfinite a -> [NegativeInfinite a]

enumFromThen :: NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

enumFromTo :: NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

enumFromThenTo :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

Eq a => Eq (NegativeInfinite a)

Methods

(==) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(/=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

Num a => Num (NegativeInfinite a)

Methods

(+) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(-) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(*) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

negate :: NegativeInfinite a -> NegativeInfinite a

abs :: NegativeInfinite a -> NegativeInfinite a

signum :: NegativeInfinite a -> NegativeInfinite a

fromInteger :: Integer -> NegativeInfinite a

Ord a => Ord (NegativeInfinite a)

Methods

compare :: NegativeInfinite a -> NegativeInfinite a -> Ordering

(<) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(<=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(>) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(>=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

max :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

min :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

Read a => Read (NegativeInfinite a)

Methods

readsPrec :: Int -> ReadS (NegativeInfinite a)

readList :: ReadS [NegativeInfinite a]

readPrec :: ReadPrec (NegativeInfinite a)

readListPrec :: ReadPrec [NegativeInfinite a]

Show a => Show (NegativeInfinite a)

Methods

showsPrec :: Int -> NegativeInfinite a -> ShowS

show :: NegativeInfinite a -> String

showList :: [NegativeInfinite a] -> ShowS

Generic (NegativeInfinite a)

Associated Types

type Rep (NegativeInfinite a) :: * -> *

Methods

from :: NegativeInfinite a -> Rep (NegativeInfinite a) x

to :: Rep (NegativeInfinite a) x -> NegativeInfinite a

Monoid a => Monoid (NegativeInfinite a)

Methods

mempty :: NegativeInfinite a

mappend :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

mconcat :: [NegativeInfinite a] -> NegativeInfinite a

Storable a => Storable (NegativeInfinite a)

Methods

sizeOf :: NegativeInfinite a -> Int

alignment :: NegativeInfinite a -> Int

peekElemOff :: Ptr (NegativeInfinite a) -> Int -> IO (NegativeInfinite a)

pokeElemOff :: Ptr (NegativeInfinite a) -> Int -> NegativeInfinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (NegativeInfinite a)

pokeByteOff :: Ptr b -> Int -> NegativeInfinite a -> IO ()

peek :: Ptr (NegativeInfinite a) -> IO (NegativeInfinite a)

poke :: Ptr (NegativeInfinite a) -> NegativeInfinite a -> IO ()

NFData a => NFData (NegativeInfinite a)

Methods

rnf :: NegativeInfinite a -> ()

Unbox a => Unbox (NegativeInfinite a)

HasNegativeInfinity (NegativeInfinite a)

Methods

negativeInfinity :: NegativeInfinite a

isNegativeInfinity :: NegativeInfinite a -> Bool

DetectableZero a => DetectableZero (NegativeInfinite a)

Methods

isZero :: NegativeInfinite a -> Bool

DetectableZero a => Semiring (NegativeInfinite a)

Doesn't follow annihilateL or mulDistribR.

Methods

zero :: NegativeInfinite a

one :: NegativeInfinite a

(<.>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(<+>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

add :: [NegativeInfinite a] -> NegativeInfinite a

mul :: [NegativeInfinite a] -> NegativeInfinite a

type Rep1 NegativeInfinite

type Rep1 NegativeInfinite = D1 (MetaData "NegativeInfinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "NegativeInfinity" PrefixI False) U1) (C1 (MetaCons "NegFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

data MVector s (NegativeInfinite a)

data MVector s (NegativeInfinite a) = MV_NegativeInfinite !(MVector s Bool) !(MVector s a)

type Rep (NegativeInfinite a)

type Rep (NegativeInfinite a) = D1 (MetaData "NegativeInfinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "NegativeInfinity" PrefixI False) U1) (C1 (MetaCons "NegFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))

data Vector (NegativeInfinite a)

data Vector (NegativeInfinite a) = V_NegativeInfinite !(Vector Bool) !(Vector a)

data PositiveInfinite a

Adds positive infinity to a type. Useful for expressing detectable infinity in types like Integer, etc.

Constructors

PosFinite !a

PositiveInfinity

Instances

Functor PositiveInfinite

Methods

fmap :: (a -> b) -> PositiveInfinite a -> PositiveInfinite b

(<$) :: a -> PositiveInfinite b -> PositiveInfinite a

Applicative PositiveInfinite

Methods

pure :: a -> PositiveInfinite a

(<*>) :: PositiveInfinite (a -> b) -> PositiveInfinite a -> PositiveInfinite b

(*>) :: PositiveInfinite a -> PositiveInfinite b -> PositiveInfinite b

(<*) :: PositiveInfinite a -> PositiveInfinite b -> PositiveInfinite a

Foldable PositiveInfinite

Methods

fold :: Monoid m => PositiveInfinite m -> m

foldMap :: Monoid m => (a -> m) -> PositiveInfinite a -> m

foldr :: (a -> b -> b) -> b -> PositiveInfinite a -> b

foldr' :: (a -> b -> b) -> b -> PositiveInfinite a -> b

foldl :: (b -> a -> b) -> b -> PositiveInfinite a -> b

foldl' :: (b -> a -> b) -> b -> PositiveInfinite a -> b

foldr1 :: (a -> a -> a) -> PositiveInfinite a -> a

foldl1 :: (a -> a -> a) -> PositiveInfinite a -> a

toList :: PositiveInfinite a -> [a]

null :: PositiveInfinite a -> Bool

length :: PositiveInfinite a -> Int

elem :: Eq a => a -> PositiveInfinite a -> Bool

maximum :: Ord a => PositiveInfinite a -> a

minimum :: Ord a => PositiveInfinite a -> a

sum :: Num a => PositiveInfinite a -> a

product :: Num a => PositiveInfinite a -> a

Traversable PositiveInfinite

Methods

traverse :: Applicative f => (a -> f b) -> PositiveInfinite a -> f (PositiveInfinite b)

sequenceA :: Applicative f => PositiveInfinite (f a) -> f (PositiveInfinite a)

mapM :: Monad m => (a -> m b) -> PositiveInfinite a -> m (PositiveInfinite b)

sequence :: Monad m => PositiveInfinite (m a) -> m (PositiveInfinite a)

Generic1 PositiveInfinite

Associated Types

type Rep1 (PositiveInfinite :: * -> *) :: * -> *

Methods

from1 :: PositiveInfinite a -> Rep1 PositiveInfinite a

to1 :: Rep1 PositiveInfinite a -> PositiveInfinite a

Eq1 PositiveInfinite

Methods

liftEq :: (a -> b -> Bool) -> PositiveInfinite a -> PositiveInfinite b -> Bool

Ord1 PositiveInfinite

Methods

liftCompare :: (a -> b -> Ordering) -> PositiveInfinite a -> PositiveInfinite b -> Ordering

Read1 PositiveInfinite

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PositiveInfinite a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [PositiveInfinite a]

Show1 PositiveInfinite

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> PositiveInfinite a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [PositiveInfinite a] -> ShowS

Unbox a => Vector Vector (PositiveInfinite a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (PositiveInfinite a) -> m (Vector (PositiveInfinite a))

basicUnsafeThaw :: PrimMonad m => Vector (PositiveInfinite a) -> m (Mutable Vector (PrimState m) (PositiveInfinite a))

basicLength :: Vector (PositiveInfinite a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (PositiveInfinite a) -> Vector (PositiveInfinite a)

basicUnsafeIndexM :: Monad m => Vector (PositiveInfinite a) -> Int -> m (PositiveInfinite a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (PositiveInfinite a) -> Vector (PositiveInfinite a) -> m ()

elemseq :: Vector (PositiveInfinite a) -> PositiveInfinite a -> b -> b

Unbox a => MVector MVector (PositiveInfinite a)

Methods

basicLength :: MVector s (PositiveInfinite a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (PositiveInfinite a) -> MVector s (PositiveInfinite a)

basicOverlaps :: MVector s (PositiveInfinite a) -> MVector s (PositiveInfinite a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (PositiveInfinite a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> PositiveInfinite a -> m (MVector (PrimState m) (PositiveInfinite a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> Int -> m (PositiveInfinite a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> Int -> PositiveInfinite a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> PositiveInfinite a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> MVector (PrimState m) (PositiveInfinite a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> MVector (PrimState m) (PositiveInfinite a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (PositiveInfinite a) -> Int -> m (MVector (PrimState m) (PositiveInfinite a))

Bounded a => Bounded (PositiveInfinite a)

Methods

minBound :: PositiveInfinite a

maxBound :: PositiveInfinite a

(Enum a, Bounded a, Eq a) => Enum (PositiveInfinite a)

Methods

succ :: PositiveInfinite a -> PositiveInfinite a

pred :: PositiveInfinite a -> PositiveInfinite a

toEnum :: Int -> PositiveInfinite a

fromEnum :: PositiveInfinite a -> Int

enumFrom :: PositiveInfinite a -> [PositiveInfinite a]

enumFromThen :: PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

enumFromTo :: PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

enumFromThenTo :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

Eq a => Eq (PositiveInfinite a)

Methods

(==) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(/=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

Num a => Num (PositiveInfinite a)

Methods

(+) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(-) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(*) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

negate :: PositiveInfinite a -> PositiveInfinite a

abs :: PositiveInfinite a -> PositiveInfinite a

signum :: PositiveInfinite a -> PositiveInfinite a

fromInteger :: Integer -> PositiveInfinite a

Ord a => Ord (PositiveInfinite a)

Methods

compare :: PositiveInfinite a -> PositiveInfinite a -> Ordering

(<) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(<=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(>) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(>=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

max :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

min :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

Read a => Read (PositiveInfinite a)

Methods

readsPrec :: Int -> ReadS (PositiveInfinite a)

readList :: ReadS [PositiveInfinite a]

readPrec :: ReadPrec (PositiveInfinite a)

readListPrec :: ReadPrec [PositiveInfinite a]

Show a => Show (PositiveInfinite a)

Methods

showsPrec :: Int -> PositiveInfinite a -> ShowS

show :: PositiveInfinite a -> String

showList :: [PositiveInfinite a] -> ShowS

Generic (PositiveInfinite a)

Associated Types

type Rep (PositiveInfinite a) :: * -> *

Methods

from :: PositiveInfinite a -> Rep (PositiveInfinite a) x

to :: Rep (PositiveInfinite a) x -> PositiveInfinite a

Monoid a => Monoid (PositiveInfinite a)

Methods

mempty :: PositiveInfinite a

mappend :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

mconcat :: [PositiveInfinite a] -> PositiveInfinite a

Storable a => Storable (PositiveInfinite a)

Methods

sizeOf :: PositiveInfinite a -> Int

alignment :: PositiveInfinite a -> Int

peekElemOff :: Ptr (PositiveInfinite a) -> Int -> IO (PositiveInfinite a)

pokeElemOff :: Ptr (PositiveInfinite a) -> Int -> PositiveInfinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (PositiveInfinite a)

pokeByteOff :: Ptr b -> Int -> PositiveInfinite a -> IO ()

peek :: Ptr (PositiveInfinite a) -> IO (PositiveInfinite a)

poke :: Ptr (PositiveInfinite a) -> PositiveInfinite a -> IO ()

NFData a => NFData (PositiveInfinite a)

Methods

rnf :: PositiveInfinite a -> ()

Unbox a => Unbox (PositiveInfinite a)

HasPositiveInfinity (PositiveInfinite a)

Methods

positiveInfinity :: PositiveInfinite a

isPositiveInfinity :: PositiveInfinite a -> Bool

DetectableZero a => DetectableZero (PositiveInfinite a)

Methods

isZero :: PositiveInfinite a -> Bool

DetectableZero a => StarSemiring (PositiveInfinite a)

Methods

star :: PositiveInfinite a -> PositiveInfinite a

plus :: PositiveInfinite a -> PositiveInfinite a

DetectableZero a => Semiring (PositiveInfinite a)

Only lawful when used with positive numbers.

Methods

zero :: PositiveInfinite a

one :: PositiveInfinite a

(<.>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(<+>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

add :: [PositiveInfinite a] -> PositiveInfinite a

mul :: [PositiveInfinite a] -> PositiveInfinite a

type Rep1 PositiveInfinite

type Rep1 PositiveInfinite = D1 (MetaData "PositiveInfinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "PosFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)) (C1 (MetaCons "PositiveInfinity" PrefixI False) U1))

data MVector s (PositiveInfinite a)

data MVector s (PositiveInfinite a) = MV_PositiveInfinite !(MVector s Bool) !(MVector s a)

type Rep (PositiveInfinite a)

type Rep (PositiveInfinite a) = D1 (MetaData "PositiveInfinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "PosFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "PositiveInfinity" PrefixI False) U1))

data Vector (PositiveInfinite a)

data Vector (PositiveInfinite a) = V_PositiveInfinite !(Vector Bool) !(Vector a)

data Infinite a

Adds positive and negative infinity to a type. Useful for expressing detectable infinity in types like Integer, etc.

Constructors

Negative

Finite !a

Positive

Instances

Functor Infinite

Methods

fmap :: (a -> b) -> Infinite a -> Infinite b

(<$) :: a -> Infinite b -> Infinite a

Applicative Infinite

Methods

pure :: a -> Infinite a

(<*>) :: Infinite (a -> b) -> Infinite a -> Infinite b

(*>) :: Infinite a -> Infinite b -> Infinite b

(<*) :: Infinite a -> Infinite b -> Infinite a

Foldable Infinite

Methods

fold :: Monoid m => Infinite m -> m

foldMap :: Monoid m => (a -> m) -> Infinite a -> m

foldr :: (a -> b -> b) -> b -> Infinite a -> b

foldr' :: (a -> b -> b) -> b -> Infinite a -> b

foldl :: (b -> a -> b) -> b -> Infinite a -> b

foldl' :: (b -> a -> b) -> b -> Infinite a -> b

foldr1 :: (a -> a -> a) -> Infinite a -> a

foldl1 :: (a -> a -> a) -> Infinite a -> a

toList :: Infinite a -> [a]

null :: Infinite a -> Bool

length :: Infinite a -> Int

elem :: Eq a => a -> Infinite a -> Bool

maximum :: Ord a => Infinite a -> a

minimum :: Ord a => Infinite a -> a

sum :: Num a => Infinite a -> a

product :: Num a => Infinite a -> a

Traversable Infinite

Methods

traverse :: Applicative f => (a -> f b) -> Infinite a -> f (Infinite b)

sequenceA :: Applicative f => Infinite (f a) -> f (Infinite a)

mapM :: Monad m => (a -> m b) -> Infinite a -> m (Infinite b)

sequence :: Monad m => Infinite (m a) -> m (Infinite a)

Generic1 Infinite

Associated Types

type Rep1 (Infinite :: * -> *) :: * -> *

Methods

from1 :: Infinite a -> Rep1 Infinite a

to1 :: Rep1 Infinite a -> Infinite a

Eq1 Infinite

Methods

liftEq :: (a -> b -> Bool) -> Infinite a -> Infinite b -> Bool

Ord1 Infinite

Methods

liftCompare :: (a -> b -> Ordering) -> Infinite a -> Infinite b -> Ordering

Read1 Infinite

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Infinite a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Infinite a]

Show1 Infinite

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Infinite a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Infinite a] -> ShowS

Unbox a => Vector Vector (Infinite a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Infinite a) -> m (Vector (Infinite a))

basicUnsafeThaw :: PrimMonad m => Vector (Infinite a) -> m (Mutable Vector (PrimState m) (Infinite a))

basicLength :: Vector (Infinite a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Infinite a) -> Vector (Infinite a)

basicUnsafeIndexM :: Monad m => Vector (Infinite a) -> Int -> m (Infinite a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Infinite a) -> Vector (Infinite a) -> m ()

elemseq :: Vector (Infinite a) -> Infinite a -> b -> b

Unbox a => MVector MVector (Infinite a)

Methods

basicLength :: MVector s (Infinite a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Infinite a) -> MVector s (Infinite a)

basicOverlaps :: MVector s (Infinite a) -> MVector s (Infinite a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Infinite a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Infinite a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Infinite a -> m (MVector (PrimState m) (Infinite a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Infinite a) -> Int -> m (Infinite a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Infinite a) -> Int -> Infinite a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Infinite a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Infinite a) -> Infinite a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Infinite a) -> MVector (PrimState m) (Infinite a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Infinite a) -> MVector (PrimState m) (Infinite a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Infinite a) -> Int -> m (MVector (PrimState m) (Infinite a))

Bounded (Infinite a)

Methods

minBound :: Infinite a

maxBound :: Infinite a

(Enum a, Bounded a, Eq a) => Enum (Infinite a)

Methods

succ :: Infinite a -> Infinite a

pred :: Infinite a -> Infinite a

toEnum :: Int -> Infinite a

fromEnum :: Infinite a -> Int

enumFrom :: Infinite a -> [Infinite a]

enumFromThen :: Infinite a -> Infinite a -> [Infinite a]

enumFromTo :: Infinite a -> Infinite a -> [Infinite a]

enumFromThenTo :: Infinite a -> Infinite a -> Infinite a -> [Infinite a]

Eq a => Eq (Infinite a)

Methods

(==) :: Infinite a -> Infinite a -> Bool

(/=) :: Infinite a -> Infinite a -> Bool

Num a => Num (Infinite a)

Methods

(+) :: Infinite a -> Infinite a -> Infinite a

(-) :: Infinite a -> Infinite a -> Infinite a

(*) :: Infinite a -> Infinite a -> Infinite a

negate :: Infinite a -> Infinite a

abs :: Infinite a -> Infinite a

signum :: Infinite a -> Infinite a

fromInteger :: Integer -> Infinite a

Ord a => Ord (Infinite a)

Methods

compare :: Infinite a -> Infinite a -> Ordering

(<) :: Infinite a -> Infinite a -> Bool

(<=) :: Infinite a -> Infinite a -> Bool

(>) :: Infinite a -> Infinite a -> Bool

(>=) :: Infinite a -> Infinite a -> Bool

max :: Infinite a -> Infinite a -> Infinite a

min :: Infinite a -> Infinite a -> Infinite a

Read a => Read (Infinite a)

Methods

readsPrec :: Int -> ReadS (Infinite a)

readList :: ReadS [Infinite a]

readPrec :: ReadPrec (Infinite a)

readListPrec :: ReadPrec [Infinite a]

Show a => Show (Infinite a)

Methods

showsPrec :: Int -> Infinite a -> ShowS

show :: Infinite a -> String

showList :: [Infinite a] -> ShowS

Generic (Infinite a)

Associated Types

type Rep (Infinite a) :: * -> *

Methods

from :: Infinite a -> Rep (Infinite a) x

to :: Rep (Infinite a) x -> Infinite a

Monoid a => Monoid (Infinite a)

Methods

mempty :: Infinite a

mappend :: Infinite a -> Infinite a -> Infinite a

mconcat :: [Infinite a] -> Infinite a

Storable a => Storable (Infinite a)

Methods

sizeOf :: Infinite a -> Int

alignment :: Infinite a -> Int

peekElemOff :: Ptr (Infinite a) -> Int -> IO (Infinite a)

pokeElemOff :: Ptr (Infinite a) -> Int -> Infinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Infinite a)

pokeByteOff :: Ptr b -> Int -> Infinite a -> IO ()

peek :: Ptr (Infinite a) -> IO (Infinite a)

poke :: Ptr (Infinite a) -> Infinite a -> IO ()

NFData a => NFData (Infinite a)

Methods

rnf :: Infinite a -> ()

Unbox a => Unbox (Infinite a)

HasNegativeInfinity (Infinite a)

Methods

negativeInfinity :: Infinite a

isNegativeInfinity :: Infinite a -> Bool

HasPositiveInfinity (Infinite a)

Methods

positiveInfinity :: Infinite a

isPositiveInfinity :: Infinite a -> Bool

(DetectableZero a, Ord a) => DetectableZero (Infinite a)

Methods

isZero :: Infinite a -> Bool

(DetectableZero a, Ord a) => Semiring (Infinite a)

Not distributive.

Methods

zero :: Infinite a

one :: Infinite a

(<.>) :: Infinite a -> Infinite a -> Infinite a

(<+>) :: Infinite a -> Infinite a -> Infinite a

add :: [Infinite a] -> Infinite a

mul :: [Infinite a] -> Infinite a

type Rep1 Infinite

type Rep1 Infinite = D1 (MetaData "Infinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "Negative" PrefixI False) U1) ((:+:) (C1 (MetaCons "Finite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)) (C1 (MetaCons "Positive" PrefixI False) U1)))

data MVector s (Infinite a)

data MVector s (Infinite a) = MV_Infinite !(MVector s Word8) !(MVector s a)

type Rep (Infinite a)

type Rep (Infinite a) = D1 (MetaData "Infinite" "Data.Semiring.Infinite" "semiring-num-1.6.0.1-8yxfjgH769H6fJUPVjj5lJ" False) ((:+:) (C1 (MetaCons "Negative" PrefixI False) U1) ((:+:) (C1 (MetaCons "Finite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Positive" PrefixI False) U1)))

data Vector (Infinite a)

data Vector (Infinite a) = V_Infinite !(Vector Word8) !(Vector a)