semiring-num-0.1.0.1: Basic semiring class and instances

LicenseMIT
Maintainer[email protected]
Stabilityexperimental
Safe HaskellNone
LanguageHaskell2010

Data.Semiring

Description

 

Synopsis

Documentation

class Semiring a where Source #

A Semiring is like the the combination of two Monoids. The first is called <+>; it has the identity element zero, and it is commutative. The second is called <.>; it has identity element one, and it must distribute over <+>.

Laws

Normal Monoid laws

Commutativity of <+>

Distribution of <.> over <+>

Another useful law, annihilation, may be deduced from the axioms above:

Methods

zero :: a Source #

The identity of <+>.

one :: a Source #

The identity of <.>.

(<.>) :: a -> a -> a infixl 7 Source #

An associative binary operation, which distributes over <+>.

(<+>) :: a -> a -> a infixl 6 Source #

An associative, commutative binary operation.

zero :: Num a => a Source #

The identity of <+>.

one :: Num a => a Source #

The identity of <.>.

(<+>) :: Num a => a -> a -> a infixl 6 Source #

An associative, commutative binary operation.

(<.>) :: Num a => a -> a -> a infixl 7 Source #

An associative binary operation, which distributes over <+>.

Instances

Semiring Bool Source # 
Semiring Int Source # 

Methods

zero :: Int Source #

one :: Int Source #

(<.>) :: Int -> Int -> Int Source #

(<+>) :: Int -> Int -> Int Source #

Semiring Int8 Source # 
Semiring Int16 Source # 
Semiring Int32 Source # 
Semiring Int64 Source # 
Semiring Integer Source # 
Semiring Word Source # 
Semiring Word8 Source # 
Semiring Word16 Source # 
Semiring Word32 Source # 
Semiring Word64 Source # 
Semiring () Source # 

Methods

zero :: () Source #

one :: () Source #

(<.>) :: () -> () -> () Source #

(<+>) :: () -> () -> () Source #

Semiring Natural Source # 
Semiring CDev Source # 
Semiring CIno Source # 
Semiring CMode Source # 
Semiring COff Source # 
Semiring CPid Source # 
Semiring CSsize Source # 
Semiring CGid Source # 
Semiring CNlink Source # 
Semiring CUid Source # 
Semiring CCc Source # 

Methods

zero :: CCc Source #

one :: CCc Source #

(<.>) :: CCc -> CCc -> CCc Source #

(<+>) :: CCc -> CCc -> CCc Source #

Semiring CSpeed Source # 
Semiring CTcflag Source # 
Semiring CRLim Source # 
Semiring Fd Source # 

Methods

zero :: Fd Source #

one :: Fd Source #

(<.>) :: Fd -> Fd -> Fd Source #

(<+>) :: Fd -> Fd -> Fd Source #

Semiring WordPtr Source # 
Semiring IntPtr Source # 
Semiring CChar Source # 
Semiring CSChar Source # 
Semiring CUChar Source # 
Semiring CShort Source # 
Semiring CUShort Source # 
Semiring CInt Source # 
Semiring CUInt Source # 
Semiring CLong Source # 
Semiring CULong Source # 
Semiring CLLong Source # 
Semiring CULLong Source # 
Semiring CFloat Source # 
Semiring CDouble Source # 
Semiring CPtrdiff Source # 
Semiring CSize Source # 
Semiring CWchar Source # 
Semiring CSigAtomic Source # 
Semiring CClock Source # 
Semiring CTime Source # 
Semiring CUSeconds Source # 
Semiring CSUSeconds Source # 
Semiring CIntPtr Source # 
Semiring CUIntPtr Source # 
Semiring CIntMax Source # 
Semiring CUIntMax Source # 
Integral a => Semiring (Ratio a) Source # 

Methods

zero :: Ratio a Source #

one :: Ratio a Source #

(<.>) :: Ratio a -> Ratio a -> Ratio a Source #

(<+>) :: Ratio a -> Ratio a -> Ratio a Source #

Semiring a => Semiring (Identity a) Source # 
(Ord a, Bounded a, Semiring a) => Semiring (Min a) Source #

The Semiring for Min uses the min operation for <+>, and normal + for <.>.

Methods

zero :: Min a Source #

one :: Min a Source #

(<.>) :: Min a -> Min a -> Min a Source #

(<+>) :: Min a -> Min a -> Min a Source #

(Ord a, Bounded a, Semiring a) => Semiring (Max a) Source #

The Semiring for Max uses the max operation for <+>, and normal + for <.>.

Methods

zero :: Max a Source #

one :: Max a Source #

(<.>) :: Max a -> Max a -> Max a Source #

(<+>) :: Max a -> Max a -> Max a Source #

HasResolution a => Semiring (Fixed a) Source # 

Methods

zero :: Fixed a Source #

one :: Fixed a Source #

(<.>) :: Fixed a -> Fixed a -> Fixed a Source #

(<+>) :: Fixed a -> Fixed a -> Fixed a Source #

RealFloat a => Semiring (Complex a) Source # 
Monoid a => Semiring (Endo a) Source #

The Endo semiring uses function composition for <.>, and pointwise mappend for <+>. The underlying Monoid needs to be commutative.

Methods

zero :: Endo a Source #

one :: Endo a Source #

(<.>) :: Endo a -> Endo a -> Endo a Source #

(<+>) :: Endo a -> Endo a -> Endo a Source #

Semiring a => Semiring (Sum a) Source # 

Methods

zero :: Sum a Source #

one :: Sum a Source #

(<.>) :: Sum a -> Sum a -> Sum a Source #

(<+>) :: Sum a -> Sum a -> Sum a Source #

Semiring a => Semiring (Product a) Source # 
(Ord a, Monoid a) => Semiring (Set a) Source #

The Set Semiring is union for <+>, and a Cartesian product for <.>.

Methods

zero :: Set a Source #

one :: Set a Source #

(<.>) :: Set a -> Set a -> Set a Source #

(<+>) :: Set a -> Set a -> Set a Source #

Semiring a => Semiring (Mul a) Source # 

Methods

zero :: Mul a Source #

one :: Mul a Source #

(<.>) :: Mul a -> Mul a -> Mul a Source #

(<+>) :: Mul a -> Mul a -> Mul a Source #

Semiring a => Semiring (Add a) Source # 

Methods

zero :: Add a Source #

one :: Add a Source #

(<.>) :: Add a -> Add a -> Add a Source #

(<+>) :: Add a -> Add a -> Add a Source #

(Ord a, Semiring a) => Semiring (Viterbi a) Source # 
(Ord a, Num a) => Semiring (Łukasiewicz a) Source # 
(Integral a, Semiring a) => Semiring (Division a) Source #

Only expects positive numbers

(Bounded a, Ord a) => Semiring (Bottleneck a) Source # 
Semiring b => Semiring (a -> b) Source #

The (->) instance is analogous to the one for Monoid.

Methods

zero :: a -> b Source #

one :: a -> b Source #

(<.>) :: (a -> b) -> (a -> b) -> a -> b Source #

(<+>) :: (a -> b) -> (a -> b) -> a -> b Source #

(Semiring a, Semiring b) => Semiring (a, b) Source # 

Methods

zero :: (a, b) Source #

one :: (a, b) Source #

(<.>) :: (a, b) -> (a, b) -> (a, b) Source #

(<+>) :: (a, b) -> (a, b) -> (a, b) Source #

(Semiring a, Semiring b, Semiring c) => Semiring (a, b, c) Source # 

Methods

zero :: (a, b, c) Source #

one :: (a, b, c) Source #

(<.>) :: (a, b, c) -> (a, b, c) -> (a, b, c) Source #

(<+>) :: (a, b, c) -> (a, b, c) -> (a, b, c) Source #

Semiring a => Semiring (Const * a b) Source # 

Methods

zero :: Const * a b Source #

one :: Const * a b Source #

(<.>) :: Const * a b -> Const * a b -> Const * a b Source #

(<+>) :: Const * a b -> Const * a b -> Const * a b Source #

(Semiring a, Semiring b, Semiring c, Semiring d) => Semiring (a, b, c, d) Source # 

Methods

zero :: (a, b, c, d) Source #

one :: (a, b, c, d) Source #

(<.>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source #

(<+>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source #

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e) => Semiring (a, b, c, d, e) Source # 

Methods

zero :: (a, b, c, d, e) Source #

one :: (a, b, c, d, e) Source #

(<.>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

(<+>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

newtype Add a Source #

Monoid under <+>. Analogous to Sum, but uses the Semiring constraint, rather than Num.

Constructors

Add 

Fields

Instances

Monad Add Source # 

Methods

(>>=) :: Add a -> (a -> Add b) -> Add b #

(>>) :: Add a -> Add b -> Add b #

return :: a -> Add a #

fail :: String -> Add a #

Functor Add Source # 

Methods

fmap :: (a -> b) -> Add a -> Add b #

(<$) :: a -> Add b -> Add a #

Applicative Add Source # 

Methods

pure :: a -> Add a #

(<*>) :: Add (a -> b) -> Add a -> Add b #

(*>) :: Add a -> Add b -> Add b #

(<*) :: Add a -> Add b -> Add a #

Foldable Add Source # 

Methods

fold :: Monoid m => Add m -> m #

foldMap :: Monoid m => (a -> m) -> Add a -> m #

foldr :: (a -> b -> b) -> b -> Add a -> b #

foldr' :: (a -> b -> b) -> b -> Add a -> b #

foldl :: (b -> a -> b) -> b -> Add a -> b #

foldl' :: (b -> a -> b) -> b -> Add a -> b #

foldr1 :: (a -> a -> a) -> Add a -> a #

foldl1 :: (a -> a -> a) -> Add a -> a #

toList :: Add a -> [a] #

null :: Add a -> Bool #

length :: Add a -> Int #

elem :: Eq a => a -> Add a -> Bool #

maximum :: Ord a => Add a -> a #

minimum :: Ord a => Add a -> a #

sum :: Num a => Add a -> a #

product :: Num a => Add a -> a #

Generic1 Add Source # 

Associated Types

type Rep1 (Add :: * -> *) :: * -> * #

Methods

from1 :: Add a -> Rep1 Add a #

to1 :: Rep1 Add a -> Add a #

Bounded a => Bounded (Add a) Source # 

Methods

minBound :: Add a #

maxBound :: Add a #

Eq a => Eq (Add a) Source # 

Methods

(==) :: Add a -> Add a -> Bool #

(/=) :: Add a -> Add a -> Bool #

Num a => Num (Add a) Source # 

Methods

(+) :: Add a -> Add a -> Add a #

(-) :: Add a -> Add a -> Add a #

(*) :: Add a -> Add a -> Add a #

negate :: Add a -> Add a #

abs :: Add a -> Add a #

signum :: Add a -> Add a #

fromInteger :: Integer -> Add a #

Ord a => Ord (Add a) Source # 

Methods

compare :: Add a -> Add a -> Ordering #

(<) :: Add a -> Add a -> Bool #

(<=) :: Add a -> Add a -> Bool #

(>) :: Add a -> Add a -> Bool #

(>=) :: Add a -> Add a -> Bool #

max :: Add a -> Add a -> Add a #

min :: Add a -> Add a -> Add a #

Read a => Read (Add a) Source # 
Show a => Show (Add a) Source # 

Methods

showsPrec :: Int -> Add a -> ShowS #

show :: Add a -> String #

showList :: [Add a] -> ShowS #

Generic (Add a) Source # 

Associated Types

type Rep (Add a) :: * -> * #

Methods

from :: Add a -> Rep (Add a) x #

to :: Rep (Add a) x -> Add a #

Semiring a => Monoid (Add a) Source # 

Methods

mempty :: Add a #

mappend :: Add a -> Add a -> Add a #

mconcat :: [Add a] -> Add a #

Arbitrary a => Arbitrary (Add a) Source # 

Methods

arbitrary :: Gen (Add a) #

shrink :: Add a -> [Add a] #

Semiring a => Semiring (Add a) Source # 

Methods

zero :: Add a Source #

one :: Add a Source #

(<.>) :: Add a -> Add a -> Add a Source #

(<+>) :: Add a -> Add a -> Add a Source #

type Rep1 Add Source # 
type Rep1 Add = D1 (MetaData "Add" "Data.Semiring" "semiring-num-0.1.0.1-IscKfbUKohaCatAOTlnAQI" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just Symbol "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))
type Rep (Add a) Source # 
type Rep (Add a) = D1 (MetaData "Add" "Data.Semiring" "semiring-num-0.1.0.1-IscKfbUKohaCatAOTlnAQI" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just Symbol "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Mul a Source #

Monoid under <.>. Analogous to Product, but uses the Semiring constraint, rather than Num.

Constructors

Mul 

Fields

Instances

Monad Mul Source # 

Methods

(>>=) :: Mul a -> (a -> Mul b) -> Mul b #

(>>) :: Mul a -> Mul b -> Mul b #

return :: a -> Mul a #

fail :: String -> Mul a #

Functor Mul Source # 

Methods

fmap :: (a -> b) -> Mul a -> Mul b #

(<$) :: a -> Mul b -> Mul a #

Applicative Mul Source # 

Methods

pure :: a -> Mul a #

(<*>) :: Mul (a -> b) -> Mul a -> Mul b #

(*>) :: Mul a -> Mul b -> Mul b #

(<*) :: Mul a -> Mul b -> Mul a #

Foldable Mul Source # 

Methods

fold :: Monoid m => Mul m -> m #

foldMap :: Monoid m => (a -> m) -> Mul a -> m #

foldr :: (a -> b -> b) -> b -> Mul a -> b #

foldr' :: (a -> b -> b) -> b -> Mul a -> b #

foldl :: (b -> a -> b) -> b -> Mul a -> b #

foldl' :: (b -> a -> b) -> b -> Mul a -> b #

foldr1 :: (a -> a -> a) -> Mul a -> a #

foldl1 :: (a -> a -> a) -> Mul a -> a #

toList :: Mul a -> [a] #

null :: Mul a -> Bool #

length :: Mul a -> Int #

elem :: Eq a => a -> Mul a -> Bool #

maximum :: Ord a => Mul a -> a #

minimum :: Ord a => Mul a -> a #

sum :: Num a => Mul a -> a #

product :: Num a => Mul a -> a #

Generic1 Mul Source # 

Associated Types

type Rep1 (Mul :: * -> *) :: * -> * #

Methods

from1 :: Mul a -> Rep1 Mul a #

to1 :: Rep1 Mul a -> Mul a #

Bounded a => Bounded (Mul a) Source # 

Methods

minBound :: Mul a #

maxBound :: Mul a #

Eq a => Eq (Mul a) Source # 

Methods

(==) :: Mul a -> Mul a -> Bool #

(/=) :: Mul a -> Mul a -> Bool #

Num a => Num (Mul a) Source # 

Methods

(+) :: Mul a -> Mul a -> Mul a #

(-) :: Mul a -> Mul a -> Mul a #

(*) :: Mul a -> Mul a -> Mul a #

negate :: Mul a -> Mul a #

abs :: Mul a -> Mul a #

signum :: Mul a -> Mul a #

fromInteger :: Integer -> Mul a #

Ord a => Ord (Mul a) Source # 

Methods

compare :: Mul a -> Mul a -> Ordering #

(<) :: Mul a -> Mul a -> Bool #

(<=) :: Mul a -> Mul a -> Bool #

(>) :: Mul a -> Mul a -> Bool #

(>=) :: Mul a -> Mul a -> Bool #

max :: Mul a -> Mul a -> Mul a #

min :: Mul a -> Mul a -> Mul a #

Read a => Read (Mul a) Source # 
Show a => Show (Mul a) Source # 

Methods

showsPrec :: Int -> Mul a -> ShowS #

show :: Mul a -> String #

showList :: [Mul a] -> ShowS #

Generic (Mul a) Source # 

Associated Types

type Rep (Mul a) :: * -> * #

Methods

from :: Mul a -> Rep (Mul a) x #

to :: Rep (Mul a) x -> Mul a #

Semiring a => Monoid (Mul a) Source # 

Methods

mempty :: Mul a #

mappend :: Mul a -> Mul a -> Mul a #

mconcat :: [Mul a] -> Mul a #

Arbitrary a => Arbitrary (Mul a) Source # 

Methods

arbitrary :: Gen (Mul a) #

shrink :: Mul a -> [Mul a] #

Semiring a => Semiring (Mul a) Source # 

Methods

zero :: Mul a Source #

one :: Mul a Source #

(<.>) :: Mul a -> Mul a -> Mul a Source #

(<+>) :: Mul a -> Mul a -> Mul a Source #

type Rep1 Mul Source # 
type Rep1 Mul = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-0.1.0.1-IscKfbUKohaCatAOTlnAQI" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just Symbol "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))
type Rep (Mul a) Source # 
type Rep (Mul a) = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-0.1.0.1-IscKfbUKohaCatAOTlnAQI" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just Symbol "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))