Data.Semiring.Numeric

Documentation

newtype Bottleneck a

Useful for some constraint problems.

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

Constructors

Bottleneck

Fields

• getBottleneck :: a

Instances

Monad Bottleneck

Methods

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

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

return :: a -> Bottleneck a

fail :: String -> Bottleneck a

Functor Bottleneck

Methods

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

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

Applicative Bottleneck

Methods

pure :: a -> Bottleneck a

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

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

(<*) :: Bottleneck 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

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) => 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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

Monad Division

Methods

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

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

return :: a -> Division a

fail :: String -> Division a

Functor Division

Methods

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

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

Applicative Division

Methods

pure :: a -> Division a

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

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

(<*) :: Division 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

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, 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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

Monad Łukasiewicz

Methods

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

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

return :: a -> Łukasiewicz a

fail :: String -> Łukasiewicz a

Functor Łukasiewicz

Methods

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

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

Applicative Łukasiewicz

Methods

pure :: a -> Łukasiewicz a

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

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

(<*) :: Łukasiewicz 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

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) => 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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

Monad Viterbi

Methods

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

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

return :: a -> Viterbi a

fail :: String -> Viterbi a

Functor Viterbi

Methods

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

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

Applicative Viterbi

Methods

pure :: a -> Viterbi a

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

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

(<*) :: Viterbi 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

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, 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" 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    = ∞ -- represented by Nothing
one     = 0

Constructors

Log

Fields

• getLog :: Maybe a

Instances

Monad Log

Methods

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

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

return :: a -> Log a

fail :: String -> Log a

Functor Log

Methods

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

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

Applicative Log

Methods

pure :: a -> Log a

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

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

(<*) :: Log 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

(Semiring a, Floating 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.6.0.0-3Tik01yeFpn7w0QSoV9lQ1" True) (C1 (MetaCons "Log" PrefixI True) (S1 (MetaSel (Just Symbol "getLog") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe)))

type Rep (Log a)

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