Data.Semiring.Numeric

Documentation

newtype Bottleneck a

Useful for some constraint problems.

(<+>) = max
(<.>) = min
zero  = minBound
one   = maxBound

Constructors

Bottleneck

Fields

• getBottleneck :: a

Instances

Functor Bottleneck

Methods

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

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

Foldable Bottleneck

Methods

fold :: Monoid m => Bottleneck m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Bottleneck a -> a

foldl1 :: (a -> a -> a) -> Bottleneck a -> a

toList :: Bottleneck a -> [a]

null :: Bottleneck a -> Bool

length :: Bottleneck a -> Int

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

maximum :: Ord a => Bottleneck a -> a

minimum :: Ord a => Bottleneck a -> a

sum :: Num a => Bottleneck a -> a

product :: Num a => Bottleneck a -> a

Traversable Bottleneck

Methods

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

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

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

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

Generic1 Bottleneck

Associated Types

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

Methods

from1 :: Bottleneck a -> Rep1 Bottleneck a

to1 :: Rep1 Bottleneck a -> Bottleneck a

Bounded a => Bounded (Bottleneck a)

Methods

minBound :: Bottleneck a

maxBound :: Bottleneck a

Enum a => Enum (Bottleneck a)

Methods

succ :: Bottleneck a -> Bottleneck a

pred :: Bottleneck a -> Bottleneck a

toEnum :: Int -> Bottleneck a

fromEnum :: Bottleneck a -> Int

enumFrom :: Bottleneck a -> [Bottleneck a]

enumFromThen :: Bottleneck a -> Bottleneck a -> [Bottleneck a]

enumFromTo :: Bottleneck a -> Bottleneck a -> [Bottleneck a]

enumFromThenTo :: Bottleneck a -> Bottleneck a -> Bottleneck a -> [Bottleneck a]

Eq a => Eq (Bottleneck a)

Methods

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

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

Fractional a => Fractional (Bottleneck a)

Methods

(/) :: Bottleneck a -> Bottleneck a -> Bottleneck a

recip :: Bottleneck a -> Bottleneck a

fromRational :: Rational -> Bottleneck a

Num a => Num (Bottleneck a)

Methods

(+) :: Bottleneck a -> Bottleneck a -> Bottleneck a

(-) :: Bottleneck a -> Bottleneck a -> Bottleneck a

(*) :: Bottleneck a -> Bottleneck a -> Bottleneck a

negate :: Bottleneck a -> Bottleneck a

abs :: Bottleneck a -> Bottleneck a

signum :: Bottleneck a -> Bottleneck a

fromInteger :: Integer -> Bottleneck a

Ord a => Ord (Bottleneck a)

Methods

compare :: Bottleneck a -> Bottleneck a -> Ordering

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

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

(>) :: Bottleneck a -> Bottleneck a -> Bool

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

max :: Bottleneck a -> Bottleneck a -> Bottleneck a

min :: Bottleneck a -> Bottleneck a -> Bottleneck a

Read a => Read (Bottleneck a)

Methods

readsPrec :: Int -> ReadS (Bottleneck a)

readList :: ReadS [Bottleneck a]

readPrec :: ReadPrec (Bottleneck a)

readListPrec :: ReadPrec [Bottleneck a]

Real a => Real (Bottleneck a)

Methods

toRational :: Bottleneck a -> Rational

RealFrac a => RealFrac (Bottleneck a)

Methods

properFraction :: Integral b => Bottleneck a -> (b, Bottleneck a)

truncate :: Integral b => Bottleneck a -> b

round :: Integral b => Bottleneck a -> b

ceiling :: Integral b => Bottleneck a -> b

floor :: Integral b => Bottleneck a -> b

Show a => Show (Bottleneck a)

Methods

showsPrec :: Int -> Bottleneck a -> ShowS

show :: Bottleneck a -> String

showList :: [Bottleneck a] -> ShowS

Generic (Bottleneck a)

Associated Types

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

Methods

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

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

Storable a => Storable (Bottleneck a)

Methods

sizeOf :: Bottleneck a -> Int

alignment :: Bottleneck a -> Int

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

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

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

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

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

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

(Bounded a, Ord a) => DetectableZero (Bottleneck a)

Methods

isZero :: Bottleneck a -> Bool

(Bounded a, Ord a) => Semiring (Bottleneck a)

Methods

zero :: Bottleneck a

one :: Bottleneck a

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

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

type Rep1 Bottleneck

type Rep1 Bottleneck = D1 (MetaData "Bottleneck" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Bottleneck" PrefixI True) (S1 (MetaSel (Just Symbol "getBottleneck") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Bottleneck a)

type Rep (Bottleneck a) = D1 (MetaData "Bottleneck" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Bottleneck" PrefixI True) (S1 (MetaSel (Just Symbol "getBottleneck") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Division a

Positive numbers only.

(<+>) = gcd
(<.>) = lcm
zero  = zero
one   = one

Constructors

Division

Fields

• getDivision :: a

Instances

Functor Division

Methods

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

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

Foldable Division

Methods

fold :: Monoid m => Division m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Division a -> a

foldl1 :: (a -> a -> a) -> Division a -> a

toList :: Division a -> [a]

null :: Division a -> Bool

length :: Division a -> Int

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

maximum :: Ord a => Division a -> a

minimum :: Ord a => Division a -> a

sum :: Num a => Division a -> a

product :: Num a => Division a -> a

Traversable Division

Methods

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

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

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

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

Generic1 Division

Associated Types

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

Methods

from1 :: Division a -> Rep1 Division a

to1 :: Rep1 Division a -> Division a

Bounded a => Bounded (Division a)

Methods

minBound :: Division a

maxBound :: Division a

Enum a => Enum (Division a)

Methods

succ :: Division a -> Division a

pred :: Division a -> Division a

toEnum :: Int -> Division a

fromEnum :: Division a -> Int

enumFrom :: Division a -> [Division a]

enumFromThen :: Division a -> Division a -> [Division a]

enumFromTo :: Division a -> Division a -> [Division a]

enumFromThenTo :: Division a -> Division a -> Division a -> [Division a]

Eq a => Eq (Division a)

Methods

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

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

Fractional a => Fractional (Division a)

Methods

(/) :: Division a -> Division a -> Division a

recip :: Division a -> Division a

fromRational :: Rational -> Division a

Num a => Num (Division a)

Methods

(+) :: Division a -> Division a -> Division a

(-) :: Division a -> Division a -> Division a

(*) :: Division a -> Division a -> Division a

negate :: Division a -> Division a

abs :: Division a -> Division a

signum :: Division a -> Division a

fromInteger :: Integer -> Division a

Ord a => Ord (Division a)

Methods

compare :: Division a -> Division a -> Ordering

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

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

(>) :: Division a -> Division a -> Bool

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

max :: Division a -> Division a -> Division a

min :: Division a -> Division a -> Division a

Read a => Read (Division a)

Methods

readsPrec :: Int -> ReadS (Division a)

readList :: ReadS [Division a]

readPrec :: ReadPrec (Division a)

readListPrec :: ReadPrec [Division a]

Real a => Real (Division a)

Methods

toRational :: Division a -> Rational

RealFrac a => RealFrac (Division a)

Methods

properFraction :: Integral b => Division a -> (b, Division a)

truncate :: Integral b => Division a -> b

round :: Integral b => Division a -> b

ceiling :: Integral b => Division a -> b

floor :: Integral b => Division a -> b

Show a => Show (Division a)

Methods

showsPrec :: Int -> Division a -> ShowS

show :: Division a -> String

showList :: [Division a] -> ShowS

Generic (Division a)

Associated Types

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

Methods

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

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

Storable a => Storable (Division a)

Methods

sizeOf :: Division a -> Int

alignment :: Division a -> Int

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

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

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

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

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

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

(Integral a, DetectableZero a) => DetectableZero (Division a)

Methods

isZero :: Division a -> Bool

(Integral a, Semiring a) => Semiring (Division a)

Only expects positive numbers

Methods

zero :: Division a

one :: Division a

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

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

type Rep1 Division

type Rep1 Division = D1 (MetaData "Division" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Division" PrefixI True) (S1 (MetaSel (Just Symbol "getDivision") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Division a)

type Rep (Division a) = D1 (MetaData "Division" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Division" PrefixI True) (S1 (MetaSel (Just Symbol "getDivision") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Łukasiewicz a

Wikipedia has some information on this. Also this paper.

(<+>)   = max
x <.> y = max 0 (x + y - 1)
zero    = zero
one     = one

Constructors

Łukasiewicz

Fields

• getŁukasiewicz :: a

Instances

Functor Łukasiewicz

Methods

fmap :: (a -> b) -> Łukasiewicz a -> Łukasiewicz b

(<$) :: a -> Łukasiewicz b -> Łukasiewicz a

Foldable Łukasiewicz

Methods

fold :: Monoid m => Łukasiewicz m -> m

foldMap :: Monoid m => (a -> m) -> Łukasiewicz a -> m

foldr :: (a -> b -> b) -> b -> Łukasiewicz a -> b

foldr' :: (a -> b -> b) -> b -> Łukasiewicz a -> b

foldl :: (b -> a -> b) -> b -> Łukasiewicz a -> b

foldl' :: (b -> a -> b) -> b -> Łukasiewicz a -> b

foldr1 :: (a -> a -> a) -> Łukasiewicz a -> a

foldl1 :: (a -> a -> a) -> Łukasiewicz a -> a

toList :: Łukasiewicz a -> [a]

null :: Łukasiewicz a -> Bool

length :: Łukasiewicz a -> Int

elem :: Eq a => a -> Łukasiewicz a -> Bool

maximum :: Ord a => Łukasiewicz a -> a

minimum :: Ord a => Łukasiewicz a -> a

sum :: Num a => Łukasiewicz a -> a

product :: Num a => Łukasiewicz a -> a

Traversable Łukasiewicz

Methods

traverse :: Applicative f => (a -> f b) -> Łukasiewicz a -> f (Łukasiewicz b)

sequenceA :: Applicative f => Łukasiewicz (f a) -> f (Łukasiewicz a)

mapM :: Monad m => (a -> m b) -> Łukasiewicz a -> m (Łukasiewicz b)

sequence :: Monad m => Łukasiewicz (m a) -> m (Łukasiewicz a)

Generic1 Łukasiewicz

Associated Types

type Rep1 (Łukasiewicz :: * -> *) :: * -> *

Methods

from1 :: Łukasiewicz a -> Rep1 Łukasiewicz a

to1 :: Rep1 Łukasiewicz a -> Łukasiewicz a

Bounded a => Bounded (Łukasiewicz a)

Methods

minBound :: Łukasiewicz a

maxBound :: Łukasiewicz a

Enum a => Enum (Łukasiewicz a)

Methods

succ :: Łukasiewicz a -> Łukasiewicz a

pred :: Łukasiewicz a -> Łukasiewicz a

toEnum :: Int -> Łukasiewicz a

fromEnum :: Łukasiewicz a -> Int

enumFrom :: Łukasiewicz a -> [Łukasiewicz a]

enumFromThen :: Łukasiewicz a -> Łukasiewicz a -> [Łukasiewicz a]

enumFromTo :: Łukasiewicz a -> Łukasiewicz a -> [Łukasiewicz a]

enumFromThenTo :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a -> [Łukasiewicz a]

Eq a => Eq (Łukasiewicz a)

Methods

(==) :: Łukasiewicz a -> Łukasiewicz a -> Bool

(/=) :: Łukasiewicz a -> Łukasiewicz a -> Bool

Fractional a => Fractional (Łukasiewicz a)

Methods

(/) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

recip :: Łukasiewicz a -> Łukasiewicz a

fromRational :: Rational -> Łukasiewicz a

Num a => Num (Łukasiewicz a)

Methods

(+) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

(-) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

(*) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

negate :: Łukasiewicz a -> Łukasiewicz a

abs :: Łukasiewicz a -> Łukasiewicz a

signum :: Łukasiewicz a -> Łukasiewicz a

fromInteger :: Integer -> Łukasiewicz a

Ord a => Ord (Łukasiewicz a)

Methods

compare :: Łukasiewicz a -> Łukasiewicz a -> Ordering

(<) :: Łukasiewicz a -> Łukasiewicz a -> Bool

(<=) :: Łukasiewicz a -> Łukasiewicz a -> Bool

(>) :: Łukasiewicz a -> Łukasiewicz a -> Bool

(>=) :: Łukasiewicz a -> Łukasiewicz a -> Bool

max :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

min :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

Read a => Read (Łukasiewicz a)

Methods

readsPrec :: Int -> ReadS (Łukasiewicz a)

readList :: ReadS [Łukasiewicz a]

readPrec :: ReadPrec (Łukasiewicz a)

readListPrec :: ReadPrec [Łukasiewicz a]

Real a => Real (Łukasiewicz a)

Methods

toRational :: Łukasiewicz a -> Rational

RealFrac a => RealFrac (Łukasiewicz a)

Methods

properFraction :: Integral b => Łukasiewicz a -> (b, Łukasiewicz a)

truncate :: Integral b => Łukasiewicz a -> b

round :: Integral b => Łukasiewicz a -> b

ceiling :: Integral b => Łukasiewicz a -> b

floor :: Integral b => Łukasiewicz a -> b

Show a => Show (Łukasiewicz a)

Methods

showsPrec :: Int -> Łukasiewicz a -> ShowS

show :: Łukasiewicz a -> String

showList :: [Łukasiewicz a] -> ShowS

Generic (Łukasiewicz a)

Associated Types

type Rep (Łukasiewicz a) :: * -> *

Methods

from :: Łukasiewicz a -> Rep (Łukasiewicz a) x

to :: Rep (Łukasiewicz a) x -> Łukasiewicz a

Storable a => Storable (Łukasiewicz a)

Methods

sizeOf :: Łukasiewicz a -> Int

alignment :: Łukasiewicz a -> Int

peekElemOff :: Ptr (Łukasiewicz a) -> Int -> IO (Łukasiewicz a)

pokeElemOff :: Ptr (Łukasiewicz a) -> Int -> Łukasiewicz a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Łukasiewicz a)

pokeByteOff :: Ptr b -> Int -> Łukasiewicz a -> IO ()

peek :: Ptr (Łukasiewicz a) -> IO (Łukasiewicz a)

poke :: Ptr (Łukasiewicz a) -> Łukasiewicz a -> IO ()

(Ord a, Num a) => DetectableZero (Łukasiewicz a)

Methods

isZero :: Łukasiewicz a -> Bool

(Ord a, Num a) => Semiring (Łukasiewicz a)

Methods

zero :: Łukasiewicz a

one :: Łukasiewicz a

(<.>) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

(<+>) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

type Rep1 Łukasiewicz

type Rep1 Łukasiewicz = D1 (MetaData "\321ukasiewicz" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "\321ukasiewicz" PrefixI True) (S1 (MetaSel (Just Symbol "get\321ukasiewicz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Łukasiewicz a)

type Rep (Łukasiewicz a) = D1 (MetaData "\321ukasiewicz" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "\321ukasiewicz" PrefixI True) (S1 (MetaSel (Just Symbol "get\321ukasiewicz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Viterbi a

Wikipedia has some information on this. Also this paper. Apparently used for probabilistic parsing.

(<+>) = max
(<.>) = (<.>)
zero  = zero
one   = one

Constructors

Viterbi

Fields

• getViterbi :: a

Instances

Functor Viterbi

Methods

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

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

Foldable Viterbi

Methods

fold :: Monoid m => Viterbi m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Viterbi a -> a

foldl1 :: (a -> a -> a) -> Viterbi a -> a

toList :: Viterbi a -> [a]

null :: Viterbi a -> Bool

length :: Viterbi a -> Int

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

maximum :: Ord a => Viterbi a -> a

minimum :: Ord a => Viterbi a -> a

sum :: Num a => Viterbi a -> a

product :: Num a => Viterbi a -> a

Traversable Viterbi

Methods

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

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

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

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

Generic1 Viterbi

Associated Types

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

Methods

from1 :: Viterbi a -> Rep1 Viterbi a

to1 :: Rep1 Viterbi a -> Viterbi a

Bounded a => Bounded (Viterbi a)

Methods

minBound :: Viterbi a

maxBound :: Viterbi a

Enum a => Enum (Viterbi a)

Methods

succ :: Viterbi a -> Viterbi a

pred :: Viterbi a -> Viterbi a

toEnum :: Int -> Viterbi a

fromEnum :: Viterbi a -> Int

enumFrom :: Viterbi a -> [Viterbi a]

enumFromThen :: Viterbi a -> Viterbi a -> [Viterbi a]

enumFromTo :: Viterbi a -> Viterbi a -> [Viterbi a]

enumFromThenTo :: Viterbi a -> Viterbi a -> Viterbi a -> [Viterbi a]

Eq a => Eq (Viterbi a)

Methods

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

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

Fractional a => Fractional (Viterbi a)

Methods

(/) :: Viterbi a -> Viterbi a -> Viterbi a

recip :: Viterbi a -> Viterbi a

fromRational :: Rational -> Viterbi a

Num a => Num (Viterbi a)

Methods

(+) :: Viterbi a -> Viterbi a -> Viterbi a

(-) :: Viterbi a -> Viterbi a -> Viterbi a

(*) :: Viterbi a -> Viterbi a -> Viterbi a

negate :: Viterbi a -> Viterbi a

abs :: Viterbi a -> Viterbi a

signum :: Viterbi a -> Viterbi a

fromInteger :: Integer -> Viterbi a

Ord a => Ord (Viterbi a)

Methods

compare :: Viterbi a -> Viterbi a -> Ordering

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

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

(>) :: Viterbi a -> Viterbi a -> Bool

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

max :: Viterbi a -> Viterbi a -> Viterbi a

min :: Viterbi a -> Viterbi a -> Viterbi a

Read a => Read (Viterbi a)

Methods

readsPrec :: Int -> ReadS (Viterbi a)

readList :: ReadS [Viterbi a]

readPrec :: ReadPrec (Viterbi a)

readListPrec :: ReadPrec [Viterbi a]

Real a => Real (Viterbi a)

Methods

toRational :: Viterbi a -> Rational

RealFrac a => RealFrac (Viterbi a)

Methods

properFraction :: Integral b => Viterbi a -> (b, Viterbi a)

truncate :: Integral b => Viterbi a -> b

round :: Integral b => Viterbi a -> b

ceiling :: Integral b => Viterbi a -> b

floor :: Integral b => Viterbi a -> b

Show a => Show (Viterbi a)

Methods

showsPrec :: Int -> Viterbi a -> ShowS

show :: Viterbi a -> String

showList :: [Viterbi a] -> ShowS

Generic (Viterbi a)

Associated Types

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

Methods

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

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

Storable a => Storable (Viterbi a)

Methods

sizeOf :: Viterbi a -> Int

alignment :: Viterbi a -> Int

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

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

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

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

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

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

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

Methods

isZero :: Viterbi a -> Bool

(Ord a, Semiring a) => Semiring (Viterbi a)

Methods

zero :: Viterbi a

one :: Viterbi a

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

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

type Rep1 Viterbi

type Rep1 Viterbi = D1 (MetaData "Viterbi" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Viterbi" PrefixI True) (S1 (MetaSel (Just Symbol "getViterbi") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Viterbi a)

type Rep (Viterbi a) = D1 (MetaData "Viterbi" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Viterbi" PrefixI True) (S1 (MetaSel (Just Symbol "getViterbi") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Log a

Useful for optimizing multiplication, or working with large numbers.

(<.>)   = (+)
x <+> y = -(log (exp (-x) + exp (-y)))
zero    = ∞
one     = 0

Constructors

Log

Fields

• getLog :: a

Instances

Functor Log

Methods

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

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

Foldable Log

Methods

fold :: Monoid m => Log m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Log a -> a

foldl1 :: (a -> a -> a) -> Log a -> a

toList :: Log a -> [a]

null :: Log a -> Bool

length :: Log a -> Int

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

maximum :: Ord a => Log a -> a

minimum :: Ord a => Log a -> a

sum :: Num a => Log a -> a

product :: Num a => Log a -> a

Generic1 Log

Associated Types

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

Methods

from1 :: Log a -> Rep1 Log a

to1 :: Rep1 Log a -> Log a

Eq a => Eq (Log a)

Methods

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

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

Ord a => Ord (Log a)

Methods

compare :: Log a -> Log a -> Ordering

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

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

(>) :: Log a -> Log a -> Bool

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

max :: Log a -> Log a -> Log a

min :: Log a -> Log a -> Log a

Read a => Read (Log a)

Methods

readsPrec :: Int -> ReadS (Log a)

readList :: ReadS [Log a]

readPrec :: ReadPrec (Log a)

readListPrec :: ReadPrec [Log a]

Show a => Show (Log a)

Methods

showsPrec :: Int -> Log a -> ShowS

show :: Log a -> String

showList :: [Log a] -> ShowS

Generic (Log a)

Associated Types

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

Methods

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

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

(Floating a, HasPositiveInfinity a) => DetectableZero (Log a)

Methods

isZero :: Log a -> Bool

(Floating a, HasPositiveInfinity a) => Semiring (Log a)

Methods

zero :: Log a

one :: Log a

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

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

type Rep1 Log

type Rep1 Log = D1 (MetaData "Log" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Log" PrefixI True) (S1 (MetaSel (Just Symbol "getLog") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Log a)

type Rep (Log a) = D1 (MetaData "Log" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "Log" PrefixI True) (S1 (MetaSel (Just Symbol "getLog") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype PosFrac a

Constructors

PosFrac

Fields

• getPosFrac :: a

Instances

Functor PosFrac

Methods

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

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

Foldable PosFrac

Methods

fold :: Monoid m => PosFrac m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PosFrac a -> a

foldl1 :: (a -> a -> a) -> PosFrac a -> a

toList :: PosFrac a -> [a]

null :: PosFrac a -> Bool

length :: PosFrac a -> Int

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

maximum :: Ord a => PosFrac a -> a

minimum :: Ord a => PosFrac a -> a

sum :: Num a => PosFrac a -> a

product :: Num a => PosFrac a -> a

Traversable PosFrac

Methods

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

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

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

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

Generic1 PosFrac

Associated Types

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

Methods

from1 :: PosFrac a -> Rep1 PosFrac a

to1 :: Rep1 PosFrac a -> PosFrac a

(Bounded a, Semiring a) => Bounded (PosFrac a)

Methods

minBound :: PosFrac a

maxBound :: PosFrac a

Enum a => Enum (PosFrac a)

Methods

succ :: PosFrac a -> PosFrac a

pred :: PosFrac a -> PosFrac a

toEnum :: Int -> PosFrac a

fromEnum :: PosFrac a -> Int

enumFrom :: PosFrac a -> [PosFrac a]

enumFromThen :: PosFrac a -> PosFrac a -> [PosFrac a]

enumFromTo :: PosFrac a -> PosFrac a -> [PosFrac a]

enumFromThenTo :: PosFrac a -> PosFrac a -> PosFrac a -> [PosFrac a]

Eq a => Eq (PosFrac a)

Methods

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

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

Fractional a => Fractional (PosFrac a)

Methods

(/) :: PosFrac a -> PosFrac a -> PosFrac a

recip :: PosFrac a -> PosFrac a

fromRational :: Rational -> PosFrac a

Num a => Num (PosFrac a)

Methods

(+) :: PosFrac a -> PosFrac a -> PosFrac a

(-) :: PosFrac a -> PosFrac a -> PosFrac a

(*) :: PosFrac a -> PosFrac a -> PosFrac a

negate :: PosFrac a -> PosFrac a

abs :: PosFrac a -> PosFrac a

signum :: PosFrac a -> PosFrac a

fromInteger :: Integer -> PosFrac a

Ord a => Ord (PosFrac a)

Methods

compare :: PosFrac a -> PosFrac a -> Ordering

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

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

(>) :: PosFrac a -> PosFrac a -> Bool

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

max :: PosFrac a -> PosFrac a -> PosFrac a

min :: PosFrac a -> PosFrac a -> PosFrac a

Read a => Read (PosFrac a)

Methods

readsPrec :: Int -> ReadS (PosFrac a)

readList :: ReadS [PosFrac a]

readPrec :: ReadPrec (PosFrac a)

readListPrec :: ReadPrec [PosFrac a]

Real a => Real (PosFrac a)

Methods

toRational :: PosFrac a -> Rational

RealFrac a => RealFrac (PosFrac a)

Methods

properFraction :: Integral b => PosFrac a -> (b, PosFrac a)

truncate :: Integral b => PosFrac a -> b

round :: Integral b => PosFrac a -> b

ceiling :: Integral b => PosFrac a -> b

floor :: Integral b => PosFrac a -> b

Show a => Show (PosFrac a)

Methods

showsPrec :: Int -> PosFrac a -> ShowS

show :: PosFrac a -> String

showList :: [PosFrac a] -> ShowS

Generic (PosFrac a)

Associated Types

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

Methods

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

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

Storable a => Storable (PosFrac a)

Methods

sizeOf :: PosFrac a -> Int

alignment :: PosFrac a -> Int

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

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

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

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

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

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

(Eq a, Semiring a) => DetectableZero (PosFrac a)

Methods

isZero :: PosFrac a -> Bool

(Ord a, Fractional a, Semiring a, HasPositiveInfinity a) => StarSemiring (PosFrac a)

Methods

star :: PosFrac a -> PosFrac a

plus :: PosFrac a -> PosFrac a

Semiring a => Semiring (PosFrac a)

Methods

zero :: PosFrac a

one :: PosFrac a

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

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

type Rep1 PosFrac

type Rep1 PosFrac = D1 (MetaData "PosFrac" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "PosFrac" PrefixI True) (S1 (MetaSel (Just Symbol "getPosFrac") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (PosFrac a)

type Rep (PosFrac a) = D1 (MetaData "PosFrac" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "PosFrac" PrefixI True) (S1 (MetaSel (Just Symbol "getPosFrac") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype PosInt a

Constructors

PosInt

Fields

• getPosInt :: a

Instances

Functor PosInt

Methods

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

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

Foldable PosInt

Methods

fold :: Monoid m => PosInt m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> PosInt a -> a

foldl1 :: (a -> a -> a) -> PosInt a -> a

toList :: PosInt a -> [a]

null :: PosInt a -> Bool

length :: PosInt a -> Int

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

maximum :: Ord a => PosInt a -> a

minimum :: Ord a => PosInt a -> a

sum :: Num a => PosInt a -> a

product :: Num a => PosInt a -> a

Traversable PosInt

Methods

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

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

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

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

Generic1 PosInt

Associated Types

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

Methods

from1 :: PosInt a -> Rep1 PosInt a

to1 :: Rep1 PosInt a -> PosInt a

(Bounded a, Semiring a) => Bounded (PosInt a)

Methods

minBound :: PosInt a

maxBound :: PosInt a

Enum a => Enum (PosInt a)

Methods

succ :: PosInt a -> PosInt a

pred :: PosInt a -> PosInt a

toEnum :: Int -> PosInt a

fromEnum :: PosInt a -> Int

enumFrom :: PosInt a -> [PosInt a]

enumFromThen :: PosInt a -> PosInt a -> [PosInt a]

enumFromTo :: PosInt a -> PosInt a -> [PosInt a]

enumFromThenTo :: PosInt a -> PosInt a -> PosInt a -> [PosInt a]

Eq a => Eq (PosInt a)

Methods

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

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

Fractional a => Fractional (PosInt a)

Methods

(/) :: PosInt a -> PosInt a -> PosInt a

recip :: PosInt a -> PosInt a

fromRational :: Rational -> PosInt a

Num a => Num (PosInt a)

Methods

(+) :: PosInt a -> PosInt a -> PosInt a

(-) :: PosInt a -> PosInt a -> PosInt a

(*) :: PosInt a -> PosInt a -> PosInt a

negate :: PosInt a -> PosInt a

abs :: PosInt a -> PosInt a

signum :: PosInt a -> PosInt a

fromInteger :: Integer -> PosInt a

Ord a => Ord (PosInt a)

Methods

compare :: PosInt a -> PosInt a -> Ordering

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

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

(>) :: PosInt a -> PosInt a -> Bool

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

max :: PosInt a -> PosInt a -> PosInt a

min :: PosInt a -> PosInt a -> PosInt a

Read a => Read (PosInt a)

Methods

readsPrec :: Int -> ReadS (PosInt a)

readList :: ReadS [PosInt a]

readPrec :: ReadPrec (PosInt a)

readListPrec :: ReadPrec [PosInt a]

Real a => Real (PosInt a)

Methods

toRational :: PosInt a -> Rational

RealFrac a => RealFrac (PosInt a)

Methods

properFraction :: Integral b => PosInt a -> (b, PosInt a)

truncate :: Integral b => PosInt a -> b

round :: Integral b => PosInt a -> b

ceiling :: Integral b => PosInt a -> b

floor :: Integral b => PosInt a -> b

Show a => Show (PosInt a)

Methods

showsPrec :: Int -> PosInt a -> ShowS

show :: PosInt a -> String

showList :: [PosInt a] -> ShowS

Generic (PosInt a)

Associated Types

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

Methods

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

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

Storable a => Storable (PosInt a)

Methods

sizeOf :: PosInt a -> Int

alignment :: PosInt a -> Int

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

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

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

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

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

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

(Eq a, Semiring a) => DetectableZero (PosInt a)

Methods

isZero :: PosInt a -> Bool

(Eq a, Semiring a, HasPositiveInfinity a) => StarSemiring (PosInt a)

Methods

star :: PosInt a -> PosInt a

plus :: PosInt a -> PosInt a

Semiring a => Semiring (PosInt a)

Methods

zero :: PosInt a

one :: PosInt a

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

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

type Rep1 PosInt

type Rep1 PosInt = D1 (MetaData "PosInt" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "PosInt" PrefixI True) (S1 (MetaSel (Just Symbol "getPosInt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (PosInt a)

type Rep (PosInt a) = D1 (MetaData "PosInt" "Data.Semiring.Numeric" "semiring-num-0.9.0.1-8Qt8CZjRJGeJpWVt8ArYme" True) (C1 (MetaCons "PosInt" PrefixI True) (S1 (MetaSel (Just Symbol "getPosInt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))