Data.Semiring

Semiring classes

class Semiring a where

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

(a <+> b) <+> c = a <+> (b <+> c)
zero <+> a = a <+> zero = a
(a <.> b) <.> c = a <.> (b <.> c)
one <.> a = a <.> one = a

Commutativity of <+>

a <+> b = b <+> a

Distribution of <.> over <+>

a <.> (b <+> c) = (a <.> b) <+> (a <.> c)
(a <+> b) <.> c = (a <.> c) <+> (b <.> c)

Annihilation

zero <.> a = a <.> zero = zero

An ordered semiring follows the laws:

x <= y => x <+> z <= y <+> z
x <= y => x <+> z <= y <+> z
zero <= z && x <= y => x <.> z <= y <.> z && z <.> x <= z <.> y

Minimal complete definition

zero, one, (<.>), (<+>)

Methods

zero :: a

The identity of <+>.

one :: a

The identity of <.>.

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

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

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

An associative, commutative binary operation.

add :: [a] -> a

Takes the sum of the elements of a list. Analogous to sum on numbers, or or on Bools.

>>> add [1..5]
15
>>> add [False, False]
False
>>> add [False, True]
True
>>> add [True, undefined]
True

mul :: [a] -> a

Takes the product of the elements of a list. Analogous to product on numbers, or and on Bools.

>>> mul [1..5]
120
>>> mul [True, True]
True
>>> mul [True, False]
False
>>> mul [False, undefined]
False

Instances

Semiring Bool

Defined in Data.Semiring

Methods

zero :: Bool

one :: Bool

(<.>) :: Bool -> Bool -> Bool

(<+>) :: Bool -> Bool -> Bool

add :: [Bool] -> Bool

mul :: [Bool] -> Bool

Semiring Double

Defined in Data.Semiring

Methods

zero :: Double

one :: Double

(<.>) :: Double -> Double -> Double

(<+>) :: Double -> Double -> Double

add :: [Double] -> Double

mul :: [Double] -> Double

Semiring Float

Defined in Data.Semiring

Methods

zero :: Float

one :: Float

(<.>) :: Float -> Float -> Float

(<+>) :: Float -> Float -> Float

add :: [Float] -> Float

mul :: [Float] -> Float

Semiring Int

Defined in Data.Semiring

Methods

zero :: Int

one :: Int

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

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

add :: [Int] -> Int

mul :: [Int] -> Int

Semiring Int8

Defined in Data.Semiring

Methods

zero :: Int8

one :: Int8

(<.>) :: Int8 -> Int8 -> Int8

(<+>) :: Int8 -> Int8 -> Int8

add :: [Int8] -> Int8

mul :: [Int8] -> Int8

Semiring Int16

Defined in Data.Semiring

Methods

zero :: Int16

one :: Int16

(<.>) :: Int16 -> Int16 -> Int16

(<+>) :: Int16 -> Int16 -> Int16

add :: [Int16] -> Int16

mul :: [Int16] -> Int16

Semiring Int32

Defined in Data.Semiring

Methods

zero :: Int32

one :: Int32

(<.>) :: Int32 -> Int32 -> Int32

(<+>) :: Int32 -> Int32 -> Int32

add :: [Int32] -> Int32

mul :: [Int32] -> Int32

Semiring Int64

Defined in Data.Semiring

Methods

zero :: Int64

one :: Int64

(<.>) :: Int64 -> Int64 -> Int64

(<+>) :: Int64 -> Int64 -> Int64

add :: [Int64] -> Int64

mul :: [Int64] -> Int64

Semiring Integer

Defined in Data.Semiring

Methods

zero :: Integer

one :: Integer

(<.>) :: Integer -> Integer -> Integer

(<+>) :: Integer -> Integer -> Integer

add :: [Integer] -> Integer

mul :: [Integer] -> Integer

Semiring Natural

Defined in Data.Semiring

Methods

zero :: Natural

one :: Natural

(<.>) :: Natural -> Natural -> Natural

(<+>) :: Natural -> Natural -> Natural

add :: [Natural] -> Natural

mul :: [Natural] -> Natural

Semiring Word

Defined in Data.Semiring

Methods

zero :: Word

one :: Word

(<.>) :: Word -> Word -> Word

(<+>) :: Word -> Word -> Word

add :: [Word] -> Word

mul :: [Word] -> Word

Semiring Word8

Defined in Data.Semiring

Methods

zero :: Word8

one :: Word8

(<.>) :: Word8 -> Word8 -> Word8

(<+>) :: Word8 -> Word8 -> Word8

add :: [Word8] -> Word8

mul :: [Word8] -> Word8

Semiring Word16

Defined in Data.Semiring

Methods

zero :: Word16

one :: Word16

(<.>) :: Word16 -> Word16 -> Word16

(<+>) :: Word16 -> Word16 -> Word16

add :: [Word16] -> Word16

mul :: [Word16] -> Word16

Semiring Word32

Defined in Data.Semiring

Methods

zero :: Word32

one :: Word32

(<.>) :: Word32 -> Word32 -> Word32

(<+>) :: Word32 -> Word32 -> Word32

add :: [Word32] -> Word32

mul :: [Word32] -> Word32

Semiring Word64

Defined in Data.Semiring

Methods

zero :: Word64

one :: Word64

(<.>) :: Word64 -> Word64 -> Word64

(<+>) :: Word64 -> Word64 -> Word64

add :: [Word64] -> Word64

mul :: [Word64] -> Word64

Semiring ()

Defined in Data.Semiring

Methods

zero :: ()

one :: ()

(<.>) :: () -> () -> ()

(<+>) :: () -> () -> ()

add :: [()] -> ()

mul :: [()] -> ()

Semiring CDev

Defined in Data.Semiring

Methods

zero :: CDev

one :: CDev

(<.>) :: CDev -> CDev -> CDev

(<+>) :: CDev -> CDev -> CDev

add :: [CDev] -> CDev

mul :: [CDev] -> CDev

Semiring CIno

Defined in Data.Semiring

Methods

zero :: CIno

one :: CIno

(<.>) :: CIno -> CIno -> CIno

(<+>) :: CIno -> CIno -> CIno

add :: [CIno] -> CIno

mul :: [CIno] -> CIno

Semiring CMode

Defined in Data.Semiring

Methods

zero :: CMode

one :: CMode

(<.>) :: CMode -> CMode -> CMode

(<+>) :: CMode -> CMode -> CMode

add :: [CMode] -> CMode

mul :: [CMode] -> CMode

Semiring COff

Defined in Data.Semiring

Methods

zero :: COff

one :: COff

(<.>) :: COff -> COff -> COff

(<+>) :: COff -> COff -> COff

add :: [COff] -> COff

mul :: [COff] -> COff

Semiring CPid

Defined in Data.Semiring

Methods

zero :: CPid

one :: CPid

(<.>) :: CPid -> CPid -> CPid

(<+>) :: CPid -> CPid -> CPid

add :: [CPid] -> CPid

mul :: [CPid] -> CPid

Semiring CSsize

Defined in Data.Semiring

Methods

zero :: CSsize

one :: CSsize

(<.>) :: CSsize -> CSsize -> CSsize

(<+>) :: CSsize -> CSsize -> CSsize

add :: [CSsize] -> CSsize

mul :: [CSsize] -> CSsize

Semiring CGid

Defined in Data.Semiring

Methods

zero :: CGid

one :: CGid

(<.>) :: CGid -> CGid -> CGid

(<+>) :: CGid -> CGid -> CGid

add :: [CGid] -> CGid

mul :: [CGid] -> CGid

Semiring CNlink

Defined in Data.Semiring

Methods

zero :: CNlink

one :: CNlink

(<.>) :: CNlink -> CNlink -> CNlink

(<+>) :: CNlink -> CNlink -> CNlink

add :: [CNlink] -> CNlink

mul :: [CNlink] -> CNlink

Semiring CUid

Defined in Data.Semiring

Methods

zero :: CUid

one :: CUid

(<.>) :: CUid -> CUid -> CUid

(<+>) :: CUid -> CUid -> CUid

add :: [CUid] -> CUid

mul :: [CUid] -> CUid

Semiring CCc

Defined in Data.Semiring

Methods

zero :: CCc

one :: CCc

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

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

add :: [CCc] -> CCc

mul :: [CCc] -> CCc

Semiring CSpeed

Defined in Data.Semiring

Methods

zero :: CSpeed

one :: CSpeed

(<.>) :: CSpeed -> CSpeed -> CSpeed

(<+>) :: CSpeed -> CSpeed -> CSpeed

add :: [CSpeed] -> CSpeed

mul :: [CSpeed] -> CSpeed

Semiring CTcflag

Defined in Data.Semiring

Methods

zero :: CTcflag

one :: CTcflag

(<.>) :: CTcflag -> CTcflag -> CTcflag

(<+>) :: CTcflag -> CTcflag -> CTcflag

add :: [CTcflag] -> CTcflag

mul :: [CTcflag] -> CTcflag

Semiring CRLim

Defined in Data.Semiring

Methods

zero :: CRLim

one :: CRLim

(<.>) :: CRLim -> CRLim -> CRLim

(<+>) :: CRLim -> CRLim -> CRLim

add :: [CRLim] -> CRLim

mul :: [CRLim] -> CRLim

Semiring Fd

Defined in Data.Semiring

Methods

zero :: Fd

one :: Fd

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

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

add :: [Fd] -> Fd

mul :: [Fd] -> Fd

Semiring All

Defined in Data.Semiring

Methods

zero :: All

one :: All

(<.>) :: All -> All -> All

(<+>) :: All -> All -> All

add :: [All] -> All

mul :: [All] -> All

Semiring Any

Defined in Data.Semiring

Methods

zero :: Any

one :: Any

(<.>) :: Any -> Any -> Any

(<+>) :: Any -> Any -> Any

add :: [Any] -> Any

mul :: [Any] -> Any

Semiring CChar

Defined in Data.Semiring

Methods

zero :: CChar

one :: CChar

(<.>) :: CChar -> CChar -> CChar

(<+>) :: CChar -> CChar -> CChar

add :: [CChar] -> CChar

mul :: [CChar] -> CChar

Semiring CSChar

Defined in Data.Semiring

Methods

zero :: CSChar

one :: CSChar

(<.>) :: CSChar -> CSChar -> CSChar

(<+>) :: CSChar -> CSChar -> CSChar

add :: [CSChar] -> CSChar

mul :: [CSChar] -> CSChar

Semiring CUChar

Defined in Data.Semiring

Methods

zero :: CUChar

one :: CUChar

(<.>) :: CUChar -> CUChar -> CUChar

(<+>) :: CUChar -> CUChar -> CUChar

add :: [CUChar] -> CUChar

mul :: [CUChar] -> CUChar

Semiring CShort

Defined in Data.Semiring

Methods

zero :: CShort

one :: CShort

(<.>) :: CShort -> CShort -> CShort

(<+>) :: CShort -> CShort -> CShort

add :: [CShort] -> CShort

mul :: [CShort] -> CShort

Semiring CUShort

Defined in Data.Semiring

Methods

zero :: CUShort

one :: CUShort

(<.>) :: CUShort -> CUShort -> CUShort

(<+>) :: CUShort -> CUShort -> CUShort

add :: [CUShort] -> CUShort

mul :: [CUShort] -> CUShort

Semiring CInt

Defined in Data.Semiring

Methods

zero :: CInt

one :: CInt

(<.>) :: CInt -> CInt -> CInt

(<+>) :: CInt -> CInt -> CInt

add :: [CInt] -> CInt

mul :: [CInt] -> CInt

Semiring CUInt

Defined in Data.Semiring

Methods

zero :: CUInt

one :: CUInt

(<.>) :: CUInt -> CUInt -> CUInt

(<+>) :: CUInt -> CUInt -> CUInt

add :: [CUInt] -> CUInt

mul :: [CUInt] -> CUInt

Semiring CLong

Defined in Data.Semiring

Methods

zero :: CLong

one :: CLong

(<.>) :: CLong -> CLong -> CLong

(<+>) :: CLong -> CLong -> CLong

add :: [CLong] -> CLong

mul :: [CLong] -> CLong

Semiring CULong

Defined in Data.Semiring

Methods

zero :: CULong

one :: CULong

(<.>) :: CULong -> CULong -> CULong

(<+>) :: CULong -> CULong -> CULong

add :: [CULong] -> CULong

mul :: [CULong] -> CULong

Semiring CLLong

Defined in Data.Semiring

Methods

zero :: CLLong

one :: CLLong

(<.>) :: CLLong -> CLLong -> CLLong

(<+>) :: CLLong -> CLLong -> CLLong

add :: [CLLong] -> CLLong

mul :: [CLLong] -> CLLong

Semiring CULLong

Defined in Data.Semiring

Methods

zero :: CULLong

one :: CULLong

(<.>) :: CULLong -> CULLong -> CULLong

(<+>) :: CULLong -> CULLong -> CULLong

add :: [CULLong] -> CULLong

mul :: [CULLong] -> CULLong

Semiring CFloat

Defined in Data.Semiring

Methods

zero :: CFloat

one :: CFloat

(<.>) :: CFloat -> CFloat -> CFloat

(<+>) :: CFloat -> CFloat -> CFloat

add :: [CFloat] -> CFloat

mul :: [CFloat] -> CFloat

Semiring CDouble

Defined in Data.Semiring

Methods

zero :: CDouble

one :: CDouble

(<.>) :: CDouble -> CDouble -> CDouble

(<+>) :: CDouble -> CDouble -> CDouble

add :: [CDouble] -> CDouble

mul :: [CDouble] -> CDouble

Semiring CPtrdiff

Defined in Data.Semiring

Methods

zero :: CPtrdiff

one :: CPtrdiff

(<.>) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(<+>) :: CPtrdiff -> CPtrdiff -> CPtrdiff

add :: [CPtrdiff] -> CPtrdiff

mul :: [CPtrdiff] -> CPtrdiff

Semiring CSize

Defined in Data.Semiring

Methods

zero :: CSize

one :: CSize

(<.>) :: CSize -> CSize -> CSize

(<+>) :: CSize -> CSize -> CSize

add :: [CSize] -> CSize

mul :: [CSize] -> CSize

Semiring CWchar

Defined in Data.Semiring

Methods

zero :: CWchar

one :: CWchar

(<.>) :: CWchar -> CWchar -> CWchar

(<+>) :: CWchar -> CWchar -> CWchar

add :: [CWchar] -> CWchar

mul :: [CWchar] -> CWchar

Semiring CSigAtomic

Defined in Data.Semiring

Methods

zero :: CSigAtomic

one :: CSigAtomic

(<.>) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(<+>) :: CSigAtomic -> CSigAtomic -> CSigAtomic

add :: [CSigAtomic] -> CSigAtomic

mul :: [CSigAtomic] -> CSigAtomic

Semiring CClock

Defined in Data.Semiring

Methods

zero :: CClock

one :: CClock

(<.>) :: CClock -> CClock -> CClock

(<+>) :: CClock -> CClock -> CClock

add :: [CClock] -> CClock

mul :: [CClock] -> CClock

Semiring CTime

Defined in Data.Semiring

Methods

zero :: CTime

one :: CTime

(<.>) :: CTime -> CTime -> CTime

(<+>) :: CTime -> CTime -> CTime

add :: [CTime] -> CTime

mul :: [CTime] -> CTime

Semiring CUSeconds

Defined in Data.Semiring

Methods

zero :: CUSeconds

one :: CUSeconds

(<.>) :: CUSeconds -> CUSeconds -> CUSeconds

(<+>) :: CUSeconds -> CUSeconds -> CUSeconds

add :: [CUSeconds] -> CUSeconds

mul :: [CUSeconds] -> CUSeconds

Semiring CSUSeconds

Defined in Data.Semiring

Methods

zero :: CSUSeconds

one :: CSUSeconds

(<.>) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(<+>) :: CSUSeconds -> CSUSeconds -> CSUSeconds

add :: [CSUSeconds] -> CSUSeconds

mul :: [CSUSeconds] -> CSUSeconds

Semiring CIntPtr

Defined in Data.Semiring

Methods

zero :: CIntPtr

one :: CIntPtr

(<.>) :: CIntPtr -> CIntPtr -> CIntPtr

(<+>) :: CIntPtr -> CIntPtr -> CIntPtr

add :: [CIntPtr] -> CIntPtr

mul :: [CIntPtr] -> CIntPtr

Semiring CUIntPtr

Defined in Data.Semiring

Methods

zero :: CUIntPtr

one :: CUIntPtr

(<.>) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(<+>) :: CUIntPtr -> CUIntPtr -> CUIntPtr

add :: [CUIntPtr] -> CUIntPtr

mul :: [CUIntPtr] -> CUIntPtr

Semiring CIntMax

Defined in Data.Semiring

Methods

zero :: CIntMax

one :: CIntMax

(<.>) :: CIntMax -> CIntMax -> CIntMax

(<+>) :: CIntMax -> CIntMax -> CIntMax

add :: [CIntMax] -> CIntMax

mul :: [CIntMax] -> CIntMax

Semiring CUIntMax

Defined in Data.Semiring

Methods

zero :: CUIntMax

one :: CUIntMax

(<.>) :: CUIntMax -> CUIntMax -> CUIntMax

(<+>) :: CUIntMax -> CUIntMax -> CUIntMax

add :: [CUIntMax] -> CUIntMax

mul :: [CUIntMax] -> CUIntMax

Semiring WordPtr

Defined in Data.Semiring

Methods

zero :: WordPtr

one :: WordPtr

(<.>) :: WordPtr -> WordPtr -> WordPtr

(<+>) :: WordPtr -> WordPtr -> WordPtr

add :: [WordPtr] -> WordPtr

mul :: [WordPtr] -> WordPtr

Semiring IntPtr

Defined in Data.Semiring

Methods

zero :: IntPtr

one :: IntPtr

(<.>) :: IntPtr -> IntPtr -> IntPtr

(<+>) :: IntPtr -> IntPtr -> IntPtr

add :: [IntPtr] -> IntPtr

mul :: [IntPtr] -> IntPtr

Semiring Scientific

Defined in Data.Semiring

Methods

zero :: Scientific

one :: Scientific

(<.>) :: Scientific -> Scientific -> Scientific

(<+>) :: Scientific -> Scientific -> Scientific

add :: [Scientific] -> Scientific

mul :: [Scientific] -> Scientific

Semiring NominalDiffTime

Defined in Data.Semiring

Methods

zero :: NominalDiffTime

one :: NominalDiffTime

(<.>) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

(<+>) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

add :: [NominalDiffTime] -> NominalDiffTime

mul :: [NominalDiffTime] -> NominalDiffTime

Semiring DiffTime

Defined in Data.Semiring

Methods

zero :: DiffTime

one :: DiffTime

(<.>) :: DiffTime -> DiffTime -> DiffTime

(<+>) :: DiffTime -> DiffTime -> DiffTime

add :: [DiffTime] -> DiffTime

mul :: [DiffTime] -> DiffTime

Semiring a => Semiring [a]

A polynomial in x can be defined as a list of its coefficients, where the ith element is the coefficient of x^i. This is the semiring for such a list. Adapted from here.

Effort is made to allow some of these functions to fuse. The reference implementation is:

one = [one]
zero = []
[] <+> ys = ys
xs <+> [] = xs
(x:xs) <+> (y:ys) = x <+> y : (xs <+> ys)
_ <.> [] = []
xs <.> ys = foldr f [] xs where
  f x zs = map (x <.>) ys <+> (zero : zs)

Defined in Data.Semiring

Methods

zero :: [a]

one :: [a]

(<.>) :: [a] -> [a] -> [a]

(<+>) :: [a] -> [a] -> [a]

add :: [[a]] -> [a]

mul :: [[a]] -> [a]

Integral a => Semiring (Ratio a)

Defined in Data.Semiring

Methods

zero :: Ratio a

one :: Ratio a

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

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

add :: [Ratio a] -> Ratio a

mul :: [Ratio a] -> Ratio a

RealFloat a => Semiring (Complex a)

Defined in Data.Semiring

Methods

zero :: Complex a

one :: Complex a

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

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

add :: [Complex a] -> Complex a

mul :: [Complex a] -> Complex a

HasResolution a => Semiring (Fixed a)

Defined in Data.Semiring

Methods

zero :: Fixed a

one :: Fixed a

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

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

add :: [Fixed a] -> Fixed a

mul :: [Fixed a] -> Fixed a

Semiring a => Semiring (Identity a)

Defined in Data.Semiring

Methods

zero :: Identity a

one :: Identity a

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

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

add :: [Identity a] -> Identity a

mul :: [Identity a] -> Identity a

Monoid a => Semiring (Endo a)

This is not a true semiring. In particular, it requires the underlying monoid to be commutative, and even then, it is only a near semiring. It is, however, extremely useful. For instance, this type:

forall a. Endo (Endo a)

Is a valid encoding of church numerals, with addition and multiplication being their semiring variants.

Defined in Data.Semiring

Methods

zero :: Endo a

one :: Endo a

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

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

add :: [Endo a] -> Endo a

mul :: [Endo a] -> Endo a

Semiring a => Semiring (Sum a)

Defined in Data.Semiring

Methods

zero :: Sum a

one :: Sum a

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

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

add :: [Sum a] -> Sum a

mul :: [Sum a] -> Sum a

Semiring a => Semiring (Product a)

Defined in Data.Semiring

Methods

zero :: Product a

one :: Product a

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

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

add :: [Product a] -> Product a

mul :: [Product a] -> Product a

(Monoid a, Ord a) => Semiring (Set a)

Defined in Data.Semiring

Methods

zero :: Set a

one :: Set a

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

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

add :: [Set a] -> Set a

mul :: [Set a] -> Set a

(Precise a, RealFloat a) => Semiring (SignedLog a)

Defined in Data.Semiring

Methods

zero :: SignedLog a

one :: SignedLog a

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

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

add :: [SignedLog a] -> SignedLog a

mul :: [SignedLog a] -> SignedLog a

(Precise a, RealFloat a) => Semiring (Log a)

Defined in Data.Semiring

Methods

zero :: Log a

one :: Log a

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

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

add :: [Log a] -> Log a

mul :: [Log a] -> Log a

(Monoid a, Hashable a, Eq a) => Semiring (HashSet a)

Defined in Data.Semiring

Methods

zero :: HashSet a

one :: HashSet a

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

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

add :: [HashSet a] -> HashSet a

mul :: [HashSet a] -> HashSet a

(Unbox a, Semiring a) => Semiring (Vector a)

Defined in Data.Semiring

Methods

zero :: Vector a

one :: Vector a

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

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

add :: [Vector a] -> Vector a

mul :: [Vector a] -> Vector a

(Storable a, Semiring a) => Semiring (Vector a)

Defined in Data.Semiring

Methods

zero :: Vector a

one :: Vector a

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

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

add :: [Vector a] -> Vector a

mul :: [Vector a] -> Vector a

Semiring a => Semiring (Vector a)

Defined in Data.Semiring

Methods

zero :: Vector a

one :: Vector a

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

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

add :: [Vector a] -> Vector a

mul :: [Vector a] -> Vector a

(Semiring a, Ord a, HasNegativeInfinity a) => Semiring (Max a)

Defined in Data.Semiring

Methods

zero :: Max a

one :: Max a

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

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

add :: [Max a] -> Max a

mul :: [Max a] -> Max a

(Semiring a, Ord a, HasPositiveInfinity a) => Semiring (Min a)

Defined in Data.Semiring

Methods

zero :: Min a

one :: Min a

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

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

add :: [Min a] -> Min a

mul :: [Min a] -> Min a

Semiring a => Semiring (Mul a)

Defined in Data.Semiring

Methods

zero :: Mul a

one :: Mul a

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

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

add :: [Mul a] -> Mul a

mul :: [Mul a] -> Mul a

Semiring a => Semiring (Add a)

Defined in Data.Semiring

Methods

zero :: Add a

one :: Add a

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

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

add :: [Add a] -> Add a

mul :: [Add a] -> Add a

Semiring a => Semiring (PosInt a)

Defined in Data.Semiring.Numeric

Methods

zero :: PosInt a

one :: PosInt a

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

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

add :: [PosInt a] -> PosInt a

mul :: [PosInt a] -> PosInt a

Semiring a => Semiring (PosFrac a)

Defined in Data.Semiring.Numeric

Methods

zero :: PosFrac a

one :: PosFrac a

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

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

add :: [PosFrac a] -> PosFrac a

mul :: [PosFrac a] -> PosFrac a

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

Defined in Data.Semiring.Numeric

Methods

zero :: Viterbi a

one :: Viterbi a

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

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

add :: [Viterbi a] -> Viterbi a

mul :: [Viterbi a] -> Viterbi a

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

Defined in Data.Semiring.Numeric

Methods

zero :: Łukasiewicz a

one :: Łukasiewicz a

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

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

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

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

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

Only expects positive numbers

Defined in Data.Semiring.Numeric

Methods

zero :: Division a

one :: Division a

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

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

add :: [Division a] -> Division a

mul :: [Division a] -> Division a

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

Defined in Data.Semiring.Numeric

Methods

zero :: Bottleneck a

one :: Bottleneck a

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

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

add :: [Bottleneck a] -> Bottleneck a

mul :: [Bottleneck a] -> Bottleneck a

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

Not distributive.

Defined in Data.Semiring.Infinite

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

DetectableZero a => Semiring (PositiveInfinite a)

Only lawful when used with positive numbers.

Defined in Data.Semiring.Infinite

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

DetectableZero a => Semiring (NegativeInfinite a)

Doesn't follow annihilateL or mulDistribR.

Defined in Data.Semiring.Infinite

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

Ord a => Semiring (Free a)

Defined in Data.Semiring.Free

Methods

zero :: Free a

one :: Free a

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

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

add :: [Free a] -> Free a

mul :: [Free a] -> Free a

Semiring b => Semiring (a -> b)

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

Defined in Data.Semiring

Methods

zero :: a -> b

one :: a -> b

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

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

add :: [a -> b] -> a -> b

mul :: [a -> b] -> a -> b

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

Defined in Data.Semiring

Methods

zero :: (a, b)

one :: (a, b)

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

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

add :: [(a, b)] -> (a, b)

mul :: [(a, b)] -> (a, b)

(Ord a, Monoid a, Semiring b) => Semiring (Map a b)

Defined in Data.Semiring

Methods

zero :: Map a b

one :: Map a b

(<.>) :: Map a b -> Map a b -> Map a b

(<+>) :: Map a b -> Map a b -> Map a b

add :: [Map a b] -> Map a b

mul :: [Map a b] -> Map a b

(Hashable a, Monoid a, Semiring b, Eq a) => Semiring (HashMap a b)

Defined in Data.Semiring

Methods

zero :: HashMap a b

one :: HashMap a b

(<.>) :: HashMap a b -> HashMap a b -> HashMap a b

(<+>) :: HashMap a b -> HashMap a b -> HashMap a b

add :: [HashMap a b] -> HashMap a b

mul :: [HashMap a b] -> HashMap a b

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

Defined in Data.Semiring

Methods

zero :: (a, b, c)

one :: (a, b, c)

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

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

add :: [(a, b, c)] -> (a, b, c)

mul :: [(a, b, c)] -> (a, b, c)

(Traversable f, Applicative f, Semiring a, f ~ g) => Semiring (Matrix f g a)

Defined in Data.Semiring

Methods

zero :: Matrix f g a

one :: Matrix f g a

(<.>) :: Matrix f g a -> Matrix f g a -> Matrix f g a

(<+>) :: Matrix f g a -> Matrix f g a -> Matrix f g a

add :: [Matrix f g a] -> Matrix f g a

mul :: [Matrix f g a] -> Matrix f g a

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

Defined in Data.Semiring

Methods

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

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

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

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

add :: [(a, b, c, d)] -> (a, b, c, d)

mul :: [(a, b, c, d)] -> (a, b, c, d)

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

Defined in Data.Semiring

Methods

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

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

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

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

add :: [(a, b, c, d, e)] -> (a, b, c, d, e)

mul :: [(a, b, c, d, e)] -> (a, b, c, d, e)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f) => Semiring (a, b, c, d, e, f)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f)

one :: (a, b, c, d, e, f)

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

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

add :: [(a, b, c, d, e, f)] -> (a, b, c, d, e, f)

mul :: [(a, b, c, d, e, f)] -> (a, b, c, d, e, f)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g) => Semiring (a, b, c, d, e, f, g)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g)

one :: (a, b, c, d, e, f, g)

(<.>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

(<+>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

add :: [(a, b, c, d, e, f, g)] -> (a, b, c, d, e, f, g)

mul :: [(a, b, c, d, e, f, g)] -> (a, b, c, d, e, f, g)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h) => Semiring (a, b, c, d, e, f, g, h)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h)

one :: (a, b, c, d, e, f, g, h)

(<.>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

(<+>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

add :: [(a, b, c, d, e, f, g, h)] -> (a, b, c, d, e, f, g, h)

mul :: [(a, b, c, d, e, f, g, h)] -> (a, b, c, d, e, f, g, h)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i) => Semiring (a, b, c, d, e, f, g, h, i)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i)

one :: (a, b, c, d, e, f, g, h, i)

(<.>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

(<+>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

add :: [(a, b, c, d, e, f, g, h, i)] -> (a, b, c, d, e, f, g, h, i)

mul :: [(a, b, c, d, e, f, g, h, i)] -> (a, b, c, d, e, f, g, h, i)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j) => Semiring (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j)

one :: (a, b, c, d, e, f, g, h, i, j)

(<.>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

(<+>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

add :: [(a, b, c, d, e, f, g, h, i, j)] -> (a, b, c, d, e, f, g, h, i, j)

mul :: [(a, b, c, d, e, f, g, h, i, j)] -> (a, b, c, d, e, f, g, h, i, j)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j, Semiring k) => Semiring (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j, k)

one :: (a, b, c, d, e, f, g, h, i, j, k)

(<.>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

(<+>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

add :: [(a, b, c, d, e, f, g, h, i, j, k)] -> (a, b, c, d, e, f, g, h, i, j, k)

mul :: [(a, b, c, d, e, f, g, h, i, j, k)] -> (a, b, c, d, e, f, g, h, i, j, k)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j, Semiring k, Semiring l) => Semiring (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j, k, l)

one :: (a, b, c, d, e, f, g, h, i, j, k, l)

(<.>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

(<+>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

add :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> (a, b, c, d, e, f, g, h, i, j, k, l)

mul :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> (a, b, c, d, e, f, g, h, i, j, k, l)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j, Semiring k, Semiring l, Semiring m) => Semiring (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

one :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

(<.>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(<+>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

add :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

mul :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j, Semiring k, Semiring l, Semiring m, Semiring n) => Semiring (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

one :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(<.>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(<+>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

add :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

mul :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e, Semiring f, Semiring g, Semiring h, Semiring i, Semiring j, Semiring k, Semiring l, Semiring m, Semiring n, Semiring o) => Semiring (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in Data.Semiring

Methods

zero :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

one :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

(<.>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

(<+>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

add :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

mul :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Semiring a => StarSemiring a where

A Star semiring adds one operation, star to a Semiring, such that it follows the law:

star x = one <+> x <.> star x = one <+> star x <.> x

For the semiring of types, this is equivalent to a list. When looking at the Applicative and Alternative classes as (near-) semirings, this is equivalent to the many operation.

Another operation, plus, can be defined in relation to star:

plus x = x <.> star x

This should be recognizable as a non-empty list on types, or the some operation in Alternative.

Minimal complete definition

Nothing

Methods

star :: a -> a

plus :: a -> a

Instances

StarSemiring Bool

Defined in Data.Semiring

Methods

star :: Bool -> Bool

plus :: Bool -> Bool

StarSemiring ()

Defined in Data.Semiring

Methods

star :: () -> ()

plus :: () -> ()

StarSemiring All

Defined in Data.Semiring

Methods

star :: All -> All

plus :: All -> All

StarSemiring Any

Defined in Data.Semiring

Methods

star :: Any -> Any

plus :: Any -> Any

StarSemiring a => StarSemiring [a]

Defined in Data.Semiring

Methods

star :: [a] -> [a]

plus :: [a] -> [a]

(Monoid a, Eq a) => StarSemiring (Endo a)

Defined in Data.Semiring

Methods

star :: Endo a -> Endo a

plus :: Endo a -> Endo a

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Max a)

Defined in Data.Semiring

Methods

star :: Max a -> Max a

plus :: Max a -> Max a

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Min a)

Defined in Data.Semiring

Methods

star :: Min a -> Min a

plus :: Min a -> Min a

StarSemiring a => StarSemiring (Mul a)

Defined in Data.Semiring

Methods

star :: Mul a -> Mul a

plus :: Mul a -> Mul a

StarSemiring a => StarSemiring (Add a)

Defined in Data.Semiring

Methods

star :: Add a -> Add a

plus :: Add a -> Add a

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

Defined in Data.Semiring.Numeric

Methods

star :: PosInt a -> PosInt a

plus :: PosInt a -> PosInt a

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

Defined in Data.Semiring.Numeric

Methods

star :: PosFrac a -> PosFrac a

plus :: PosFrac a -> PosFrac a

DetectableZero a => StarSemiring (PositiveInfinite a)

Defined in Data.Semiring.Infinite

Methods

star :: PositiveInfinite a -> PositiveInfinite a

plus :: PositiveInfinite a -> PositiveInfinite a

StarSemiring b => StarSemiring (a -> b)

Defined in Data.Semiring

Methods

star :: (a -> b) -> a -> b

plus :: (a -> b) -> a -> b

(StarSemiring a, StarSemiring b) => StarSemiring (a, b)

Defined in Data.Semiring

Methods

star :: (a, b) -> (a, b)

plus :: (a, b) -> (a, b)

(StarSemiring a, StarSemiring b, StarSemiring c) => StarSemiring (a, b, c)

Defined in Data.Semiring

Methods

star :: (a, b, c) -> (a, b, c)

plus :: (a, b, c) -> (a, b, c)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d) => StarSemiring (a, b, c, d)

Defined in Data.Semiring

Methods

star :: (a, b, c, d) -> (a, b, c, d)

plus :: (a, b, c, d) -> (a, b, c, d)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e) => StarSemiring (a, b, c, d, e)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e) -> (a, b, c, d, e)

plus :: (a, b, c, d, e) -> (a, b, c, d, e)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f) => StarSemiring (a, b, c, d, e, f)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f) -> (a, b, c, d, e, f)

plus :: (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g) => StarSemiring (a, b, c, d, e, f, g)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

plus :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h) => StarSemiring (a, b, c, d, e, f, g, h)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

plus :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i) => StarSemiring (a, b, c, d, e, f, g, h, i)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

plus :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j) => StarSemiring (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

plus :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j, StarSemiring k) => StarSemiring (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

plus :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j, StarSemiring k, StarSemiring l) => StarSemiring (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

plus :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j, StarSemiring k, StarSemiring l, StarSemiring m) => StarSemiring (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

plus :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j, StarSemiring k, StarSemiring l, StarSemiring m, StarSemiring n) => StarSemiring (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

plus :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(StarSemiring a, StarSemiring b, StarSemiring c, StarSemiring d, StarSemiring e, StarSemiring f, StarSemiring g, StarSemiring h, StarSemiring i, StarSemiring j, StarSemiring k, StarSemiring l, StarSemiring m, StarSemiring n, StarSemiring o) => StarSemiring (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in Data.Semiring

Methods

star :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

plus :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

mulFoldable :: (Foldable f, Semiring a) => f a -> a

The product of the contents of a Foldable.

addFoldable :: (Foldable f, Semiring a) => f a -> a

The sum of the contents of a Foldable.

Helper classes

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.

Methods

positiveInfinity :: a

A positive infinite value

isPositiveInfinity :: a -> Bool

Test if a value is positive infinity.

Instances

HasPositiveInfinity Double

Defined in Data.Semiring

Methods

positiveInfinity :: Double

isPositiveInfinity :: Double -> Bool

HasPositiveInfinity Float

Defined in Data.Semiring

Methods

positiveInfinity :: Float

isPositiveInfinity :: Float -> Bool

HasPositiveInfinity CFloat

Defined in Data.Semiring

Methods

positiveInfinity :: CFloat

isPositiveInfinity :: CFloat -> Bool

HasPositiveInfinity CDouble

Defined in Data.Semiring

Methods

positiveInfinity :: CDouble

isPositiveInfinity :: CDouble -> Bool

HasPositiveInfinity (Infinite a)

Defined in Data.Semiring.Infinite

Methods

positiveInfinity :: Infinite a

isPositiveInfinity :: Infinite a -> Bool

HasPositiveInfinity (PositiveInfinite a)

Defined in Data.Semiring.Infinite

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.

Methods

negativeInfinity :: a

A negative infinite value

isNegativeInfinity :: a -> Bool

Test if a value is negative infinity.

Instances

HasNegativeInfinity Double

Defined in Data.Semiring

Methods

negativeInfinity :: Double

isNegativeInfinity :: Double -> Bool

HasNegativeInfinity Float

Defined in Data.Semiring

Methods

negativeInfinity :: Float

isNegativeInfinity :: Float -> Bool

HasNegativeInfinity CFloat

Defined in Data.Semiring

Methods

negativeInfinity :: CFloat

isNegativeInfinity :: CFloat -> Bool

HasNegativeInfinity CDouble

Defined in Data.Semiring

Methods

negativeInfinity :: CDouble

isNegativeInfinity :: CDouble -> Bool

HasNegativeInfinity (Infinite a)

Defined in Data.Semiring.Infinite

Methods

negativeInfinity :: Infinite a

isNegativeInfinity :: Infinite a -> Bool

HasNegativeInfinity (NegativeInfinite a)

Defined in Data.Semiring.Infinite

Methods

negativeInfinity :: NegativeInfinite a

isNegativeInfinity :: NegativeInfinite a -> Bool

class Semiring a => DetectableZero a where

Useful for operations where zeroes may need to be discarded: for instance in sparse matrix calculations.

Methods

isZero :: a -> Bool

True if x is zero.

Instances

DetectableZero Bool

Defined in Data.Semiring

Methods

isZero :: Bool -> Bool

DetectableZero Double

Defined in Data.Semiring

Methods

isZero :: Double -> Bool

DetectableZero Float

Defined in Data.Semiring

Methods

isZero :: Float -> Bool

DetectableZero Int

Defined in Data.Semiring

Methods

isZero :: Int -> Bool

DetectableZero Int8

Defined in Data.Semiring

Methods

isZero :: Int8 -> Bool

DetectableZero Int16

Defined in Data.Semiring

Methods

isZero :: Int16 -> Bool

DetectableZero Int32

Defined in Data.Semiring

Methods

isZero :: Int32 -> Bool

DetectableZero Int64

Defined in Data.Semiring

Methods

isZero :: Int64 -> Bool

DetectableZero Integer

Defined in Data.Semiring

Methods

isZero :: Integer -> Bool

DetectableZero Natural

Defined in Data.Semiring

Methods

isZero :: Natural -> Bool

DetectableZero Word

Defined in Data.Semiring

Methods

isZero :: Word -> Bool

DetectableZero Word8

Defined in Data.Semiring

Methods

isZero :: Word8 -> Bool

DetectableZero Word16

Defined in Data.Semiring

Methods

isZero :: Word16 -> Bool

DetectableZero Word32

Defined in Data.Semiring

Methods

isZero :: Word32 -> Bool

DetectableZero Word64

Defined in Data.Semiring

Methods

isZero :: Word64 -> Bool

DetectableZero ()

Defined in Data.Semiring

Methods

isZero :: () -> Bool

DetectableZero CDev

Defined in Data.Semiring

Methods

isZero :: CDev -> Bool

DetectableZero CIno

Defined in Data.Semiring

Methods

isZero :: CIno -> Bool

DetectableZero CMode

Defined in Data.Semiring

Methods

isZero :: CMode -> Bool

DetectableZero COff

Defined in Data.Semiring

Methods

isZero :: COff -> Bool

DetectableZero CPid

Defined in Data.Semiring

Methods

isZero :: CPid -> Bool

DetectableZero CSsize

Defined in Data.Semiring

Methods

isZero :: CSsize -> Bool

DetectableZero CGid

Defined in Data.Semiring

Methods

isZero :: CGid -> Bool

DetectableZero CNlink

Defined in Data.Semiring

Methods

isZero :: CNlink -> Bool

DetectableZero CUid

Defined in Data.Semiring

Methods

isZero :: CUid -> Bool

DetectableZero CCc

Defined in Data.Semiring

Methods

isZero :: CCc -> Bool

DetectableZero CSpeed

Defined in Data.Semiring

Methods

isZero :: CSpeed -> Bool

DetectableZero CTcflag

Defined in Data.Semiring

Methods

isZero :: CTcflag -> Bool

DetectableZero CRLim

Defined in Data.Semiring

Methods

isZero :: CRLim -> Bool

DetectableZero Fd

Defined in Data.Semiring

Methods

isZero :: Fd -> Bool

DetectableZero All

Defined in Data.Semiring

Methods

isZero :: All -> Bool

DetectableZero Any

Defined in Data.Semiring

Methods

isZero :: Any -> Bool

DetectableZero CChar

Defined in Data.Semiring

Methods

isZero :: CChar -> Bool

DetectableZero CSChar

Defined in Data.Semiring

Methods

isZero :: CSChar -> Bool

DetectableZero CUChar

Defined in Data.Semiring

Methods

isZero :: CUChar -> Bool

DetectableZero CShort

Defined in Data.Semiring

Methods

isZero :: CShort -> Bool

DetectableZero CUShort

Defined in Data.Semiring

Methods

isZero :: CUShort -> Bool

DetectableZero CInt

Defined in Data.Semiring

Methods

isZero :: CInt -> Bool

DetectableZero CUInt

Defined in Data.Semiring

Methods

isZero :: CUInt -> Bool

DetectableZero CLong

Defined in Data.Semiring

Methods

isZero :: CLong -> Bool

DetectableZero CULong

Defined in Data.Semiring

Methods

isZero :: CULong -> Bool

DetectableZero CLLong

Defined in Data.Semiring

Methods

isZero :: CLLong -> Bool

DetectableZero CULLong

Defined in Data.Semiring

Methods

isZero :: CULLong -> Bool

DetectableZero CFloat

Defined in Data.Semiring

Methods

isZero :: CFloat -> Bool

DetectableZero CDouble

Defined in Data.Semiring

Methods

isZero :: CDouble -> Bool

DetectableZero CPtrdiff

Defined in Data.Semiring

Methods

isZero :: CPtrdiff -> Bool

DetectableZero CSize

Defined in Data.Semiring

Methods

isZero :: CSize -> Bool

DetectableZero CWchar

Defined in Data.Semiring

Methods

isZero :: CWchar -> Bool

DetectableZero CSigAtomic

Defined in Data.Semiring

Methods

isZero :: CSigAtomic -> Bool

DetectableZero CClock

Defined in Data.Semiring

Methods

isZero :: CClock -> Bool

DetectableZero CTime

Defined in Data.Semiring

Methods

isZero :: CTime -> Bool

DetectableZero CUSeconds

Defined in Data.Semiring

Methods

isZero :: CUSeconds -> Bool

DetectableZero CSUSeconds

Defined in Data.Semiring

Methods

isZero :: CSUSeconds -> Bool

DetectableZero CIntPtr

Defined in Data.Semiring

Methods

isZero :: CIntPtr -> Bool

DetectableZero CUIntPtr

Defined in Data.Semiring

Methods

isZero :: CUIntPtr -> Bool

DetectableZero CIntMax

Defined in Data.Semiring

Methods

isZero :: CIntMax -> Bool

DetectableZero CUIntMax

Defined in Data.Semiring

Methods

isZero :: CUIntMax -> Bool

DetectableZero WordPtr

Defined in Data.Semiring

Methods

isZero :: WordPtr -> Bool

DetectableZero IntPtr

Defined in Data.Semiring

Methods

isZero :: IntPtr -> Bool

DetectableZero Scientific

Defined in Data.Semiring

Methods

isZero :: Scientific -> Bool

DetectableZero NominalDiffTime

Defined in Data.Semiring

Methods

isZero :: NominalDiffTime -> Bool

DetectableZero DiffTime

Defined in Data.Semiring

Methods

isZero :: DiffTime -> Bool

DetectableZero a => DetectableZero [a]

Defined in Data.Semiring

Methods

isZero :: [a] -> Bool

Integral a => DetectableZero (Ratio a)

Defined in Data.Semiring

Methods

isZero :: Ratio a -> Bool

RealFloat a => DetectableZero (Complex a)

Defined in Data.Semiring

Methods

isZero :: Complex a -> Bool

HasResolution a => DetectableZero (Fixed a)

Defined in Data.Semiring

Methods

isZero :: Fixed a -> Bool

DetectableZero a => DetectableZero (Identity a)

Defined in Data.Semiring

Methods

isZero :: Identity a -> Bool

(Enum a, Bounded a, Eq a, Monoid a) => DetectableZero (Endo a)

Defined in Data.Semiring

Methods

isZero :: Endo a -> Bool

DetectableZero a => DetectableZero (Sum a)

Defined in Data.Semiring

Methods

isZero :: Sum a -> Bool

DetectableZero a => DetectableZero (Product a)

Defined in Data.Semiring

Methods

isZero :: Product a -> Bool

(Monoid a, Ord a) => DetectableZero (Set a)

Defined in Data.Semiring

Methods

isZero :: Set a -> Bool

(Precise a, RealFloat a) => DetectableZero (SignedLog a)

Defined in Data.Semiring

Methods

isZero :: SignedLog a -> Bool

(Precise a, RealFloat a) => DetectableZero (Log a)

Defined in Data.Semiring

Methods

isZero :: Log a -> Bool

(Monoid a, Hashable a, Eq a) => DetectableZero (HashSet a)

Defined in Data.Semiring

Methods

isZero :: HashSet a -> Bool

(Unbox a, DetectableZero a) => DetectableZero (Vector a)

Defined in Data.Semiring

Methods

isZero :: Vector a -> Bool

(Storable a, DetectableZero a) => DetectableZero (Vector a)

Defined in Data.Semiring

Methods

isZero :: Vector a -> Bool

DetectableZero a => DetectableZero (Vector a)

Defined in Data.Semiring

Methods

isZero :: Vector a -> Bool

(Semiring a, Ord a, HasNegativeInfinity a) => DetectableZero (Max a)

Defined in Data.Semiring

Methods

isZero :: Max a -> Bool

(Semiring a, Ord a, HasPositiveInfinity a) => DetectableZero (Min a)

Defined in Data.Semiring

Methods

isZero :: Min a -> Bool

DetectableZero a => DetectableZero (Mul a)

Defined in Data.Semiring

Methods

isZero :: Mul a -> Bool

DetectableZero a => DetectableZero (Add a)

Defined in Data.Semiring

Methods

isZero :: Add a -> Bool

DetectableZero a => DetectableZero (PosInt a)

Defined in Data.Semiring.Numeric

Methods

isZero :: PosInt a -> Bool

DetectableZero a => DetectableZero (PosFrac a)

Defined in Data.Semiring.Numeric

Methods

isZero :: PosFrac a -> Bool

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

Defined in Data.Semiring.Numeric

Methods

isZero :: Viterbi a -> Bool

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

Defined in Data.Semiring.Numeric

Methods

isZero :: Łukasiewicz a -> Bool

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

Defined in Data.Semiring.Numeric

Methods

isZero :: Division a -> Bool

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

Defined in Data.Semiring.Numeric

Methods

isZero :: Bottleneck a -> Bool

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

Defined in Data.Semiring.Infinite

Methods

isZero :: Infinite a -> Bool

DetectableZero a => DetectableZero (PositiveInfinite a)

Defined in Data.Semiring.Infinite

Methods

isZero :: PositiveInfinite a -> Bool

DetectableZero a => DetectableZero (NegativeInfinite a)

Defined in Data.Semiring.Infinite

Methods

isZero :: NegativeInfinite a -> Bool

(DetectableZero a, DetectableZero b) => DetectableZero (a, b)

Defined in Data.Semiring

Methods

isZero :: (a, b) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c) => DetectableZero (a, b, c)

Defined in Data.Semiring

Methods

isZero :: (a, b, c) -> Bool

(Traversable f, Applicative f, DetectableZero a, f ~ g) => DetectableZero (Matrix f g a)

Defined in Data.Semiring

Methods

isZero :: Matrix f g a -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d) => DetectableZero (a, b, c, d)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e) => DetectableZero (a, b, c, d, e)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f) => DetectableZero (a, b, c, d, e, f)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g) => DetectableZero (a, b, c, d, e, f, g)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h) => DetectableZero (a, b, c, d, e, f, g, h)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i) => DetectableZero (a, b, c, d, e, f, g, h, i)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j) => DetectableZero (a, b, c, d, e, f, g, h, i, j)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j, DetectableZero k) => DetectableZero (a, b, c, d, e, f, g, h, i, j, k)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j, DetectableZero k, DetectableZero l) => DetectableZero (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j, DetectableZero k, DetectableZero l, DetectableZero m) => DetectableZero (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j, DetectableZero k, DetectableZero l, DetectableZero m, DetectableZero n) => DetectableZero (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(DetectableZero a, DetectableZero b, DetectableZero c, DetectableZero d, DetectableZero e, DetectableZero f, DetectableZero g, DetectableZero h, DetectableZero i, DetectableZero j, DetectableZero k, DetectableZero l, DetectableZero m, DetectableZero n, DetectableZero o) => DetectableZero (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in Data.Semiring

Methods

isZero :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

Monoidal wrappers

newtype Add a

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

Constructors

Add

Fields

• getAdd :: a

Instances

Functor Add

Defined in Data.Semiring

Methods

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

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

Foldable Add

Defined in Data.Semiring

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

Traversable Add

Defined in Data.Semiring

Methods

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

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

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

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

Eq1 Add

Defined in Data.Semiring

Methods

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

Ord1 Add

Defined in Data.Semiring

Methods

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

Read1 Add

Defined in Data.Semiring

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Add a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Add a]

Show1 Add

Defined in Data.Semiring

Methods

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

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

Bounded a => Bounded (Add a)

Defined in Data.Semiring

Methods

minBound :: Add a

maxBound :: Add a

Enum a => Enum (Add a)

Defined in Data.Semiring

Methods

succ :: Add a -> Add a

pred :: Add a -> Add a

toEnum :: Int -> Add a

fromEnum :: Add a -> Int

enumFrom :: Add a -> [Add a]

enumFromThen :: Add a -> Add a -> [Add a]

enumFromTo :: Add a -> Add a -> [Add a]

enumFromThenTo :: Add a -> Add a -> Add a -> [Add a]

Eq a => Eq (Add a)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Add a)

Defined in Data.Semiring

Methods

(/) :: Add a -> Add a -> Add a

recip :: Add a -> Add a

fromRational :: Rational -> Add a

Num a => Num (Add a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Add a)

readList :: ReadS [Add a]

readPrec :: ReadPrec (Add a)

readListPrec :: ReadPrec [Add a]

Real a => Real (Add a)

Defined in Data.Semiring

Methods

toRational :: Add a -> Rational

RealFrac a => RealFrac (Add a)

Defined in Data.Semiring

Methods

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

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

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

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

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

Show a => Show (Add a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Add a -> ShowS

show :: Add a -> String

showList :: [Add a] -> ShowS

Generic (Add a)

Defined in Data.Semiring

Associated Types

type Rep (Add a) :: Type -> Type

Methods

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

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

Semiring a => Semigroup (Add a)

Defined in Data.Semiring

Methods

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

sconcat :: NonEmpty (Add a) -> Add a

stimes :: Integral b => b -> Add a -> Add a

Semiring a => Monoid (Add a)

Defined in Data.Semiring

Methods

mempty :: Add a

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

mconcat :: [Add a] -> Add a

Storable a => Storable (Add a)

Defined in Data.Semiring

Methods

sizeOf :: Add a -> Int

alignment :: Add a -> Int

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

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

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

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

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

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

DetectableZero a => DetectableZero (Add a)

Defined in Data.Semiring

Methods

isZero :: Add a -> Bool

StarSemiring a => StarSemiring (Add a)

Defined in Data.Semiring

Methods

star :: Add a -> Add a

plus :: Add a -> Add a

Semiring a => Semiring (Add a)

Defined in Data.Semiring

Methods

zero :: Add a

one :: Add a

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

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

add :: [Add a] -> Add a

mul :: [Add a] -> Add a

Generic1 Add

Defined in Data.Semiring

Associated Types

type Rep1 Add :: k -> Type

Methods

from1 :: Add a -> Rep1 Add a

to1 :: Rep1 Add a -> Add a

type Rep (Add a)

Defined in Data.Semiring

type Rep (Add a) = D1 (MetaData "Add" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Add

Defined in Data.Semiring

type Rep1 Add = D1 (MetaData "Add" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Mul a

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

Constructors

Mul

Fields

• getMul :: a

Instances

Functor Mul

Defined in Data.Semiring

Methods

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

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

Foldable Mul

Defined in Data.Semiring

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

Traversable Mul

Defined in Data.Semiring

Methods

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

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

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

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

Eq1 Mul

Defined in Data.Semiring

Methods

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

Ord1 Mul

Defined in Data.Semiring

Methods

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

Read1 Mul

Defined in Data.Semiring

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Mul a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Mul a]

Show1 Mul

Defined in Data.Semiring

Methods

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

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

Bounded a => Bounded (Mul a)

Defined in Data.Semiring

Methods

minBound :: Mul a

maxBound :: Mul a

Enum a => Enum (Mul a)

Defined in Data.Semiring

Methods

succ :: Mul a -> Mul a

pred :: Mul a -> Mul a

toEnum :: Int -> Mul a

fromEnum :: Mul a -> Int

enumFrom :: Mul a -> [Mul a]

enumFromThen :: Mul a -> Mul a -> [Mul a]

enumFromTo :: Mul a -> Mul a -> [Mul a]

enumFromThenTo :: Mul a -> Mul a -> Mul a -> [Mul a]

Eq a => Eq (Mul a)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Mul a)

Defined in Data.Semiring

Methods

(/) :: Mul a -> Mul a -> Mul a

recip :: Mul a -> Mul a

fromRational :: Rational -> Mul a

Num a => Num (Mul a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Mul a)

readList :: ReadS [Mul a]

readPrec :: ReadPrec (Mul a)

readListPrec :: ReadPrec [Mul a]

Real a => Real (Mul a)

Defined in Data.Semiring

Methods

toRational :: Mul a -> Rational

RealFrac a => RealFrac (Mul a)

Defined in Data.Semiring

Methods

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

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

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

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

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

Show a => Show (Mul a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Mul a -> ShowS

show :: Mul a -> String

showList :: [Mul a] -> ShowS

Generic (Mul a)

Defined in Data.Semiring

Associated Types

type Rep (Mul a) :: Type -> Type

Methods

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

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

Semiring a => Semigroup (Mul a)

Defined in Data.Semiring

Methods

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

sconcat :: NonEmpty (Mul a) -> Mul a

stimes :: Integral b => b -> Mul a -> Mul a

Semiring a => Monoid (Mul a)

Defined in Data.Semiring

Methods

mempty :: Mul a

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

mconcat :: [Mul a] -> Mul a

Storable a => Storable (Mul a)

Defined in Data.Semiring

Methods

sizeOf :: Mul a -> Int

alignment :: Mul a -> Int

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

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

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

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

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

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

DetectableZero a => DetectableZero (Mul a)

Defined in Data.Semiring

Methods

isZero :: Mul a -> Bool

StarSemiring a => StarSemiring (Mul a)

Defined in Data.Semiring

Methods

star :: Mul a -> Mul a

plus :: Mul a -> Mul a

Semiring a => Semiring (Mul a)

Defined in Data.Semiring

Methods

zero :: Mul a

one :: Mul a

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

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

add :: [Mul a] -> Mul a

mul :: [Mul a] -> Mul a

Generic1 Mul

Defined in Data.Semiring

Associated Types

type Rep1 Mul :: k -> Type

Methods

from1 :: Mul a -> Rep1 Mul a

to1 :: Rep1 Mul a -> Mul a

type Rep (Mul a)

Defined in Data.Semiring

type Rep (Mul a) = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Mul

Defined in Data.Semiring

type Rep1 Mul = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

Ordering wrappers

newtype Max a

The "Arctic" or max-plus semiring. It is a semiring where:

<+>  = max
zero = -∞
<.>  = <+>
one  = zero

Note that we can't use Max from Semigroup because annihilation needs to hold:

-∞ <+> x = x <+> -∞ = -∞

Taking -∞ to be minBound would break the above law. Using negativeInfinity to represent it follows the law.

Constructors

Max

Fields

• getMax :: a

Instances

Functor Max

Defined in Data.Semiring

Methods

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

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

Foldable Max

Defined in Data.Semiring

Methods

fold :: Monoid m => Max m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Max a -> a

foldl1 :: (a -> a -> a) -> Max a -> a

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

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

maximum :: Ord a => Max a -> a

minimum :: Ord a => Max a -> a

sum :: Num a => Max a -> a

product :: Num a => Max a -> a

Traversable Max

Defined in Data.Semiring

Methods

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

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

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

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

Eq1 Max

Defined in Data.Semiring

Methods

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

Ord1 Max

Defined in Data.Semiring

Methods

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

Read1 Max

Defined in Data.Semiring

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Max a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Max a]

Show1 Max

Defined in Data.Semiring

Methods

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

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

Unbox a => Vector Vector (Max a)

Defined in Data.Semiring

Methods

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

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

basicLength :: Vector (Max a) -> Int

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

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

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

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

Unbox a => MVector MVector (Max a)

Defined in Data.Semiring

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

Bounded a => Bounded (Max a)

Defined in Data.Semiring

Methods

minBound :: Max a

maxBound :: Max a

Enum a => Enum (Max a)

Defined in Data.Semiring

Methods

succ :: Max a -> Max a

pred :: Max a -> Max a

toEnum :: Int -> Max a

fromEnum :: Max a -> Int

enumFrom :: Max a -> [Max a]

enumFromThen :: Max a -> Max a -> [Max a]

enumFromTo :: Max a -> Max a -> [Max a]

enumFromThenTo :: Max a -> Max a -> Max a -> [Max a]

Eq a => Eq (Max a)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Max a)

Defined in Data.Semiring

Methods

(/) :: Max a -> Max a -> Max a

recip :: Max a -> Max a

fromRational :: Rational -> Max a

Num a => Num (Max a)

Defined in Data.Semiring

Methods

(+) :: Max a -> Max a -> Max a

(-) :: Max a -> Max a -> Max a

(*) :: Max a -> Max a -> Max a

negate :: Max a -> Max a

abs :: Max a -> Max a

signum :: Max a -> Max a

fromInteger :: Integer -> Max a

Ord a => Ord (Max a)

Defined in Data.Semiring

Methods

compare :: Max a -> Max a -> Ordering

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

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

(>) :: Max a -> Max a -> Bool

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

max :: Max a -> Max a -> Max a

min :: Max a -> Max a -> Max a

Read a => Read (Max a)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Max a)

readList :: ReadS [Max a]

readPrec :: ReadPrec (Max a)

readListPrec :: ReadPrec [Max a]

Real a => Real (Max a)

Defined in Data.Semiring

Methods

toRational :: Max a -> Rational

RealFrac a => RealFrac (Max a)

Defined in Data.Semiring

Methods

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

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

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

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

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

Show a => Show (Max a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Generic (Max a)

Defined in Data.Semiring

Associated Types

type Rep (Max a) :: Type -> Type

Methods

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

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

Ord a => Semigroup (Max a)

Defined in Data.Semiring

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

(Ord a, HasNegativeInfinity a) => Monoid (Max a)

>>> (getMax . foldMap Max) [1..10]
10.0

Defined in Data.Semiring

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Storable a => Storable (Max a)

Defined in Data.Semiring

Methods

sizeOf :: Max a -> Int

alignment :: Max a -> Int

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

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

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

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

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

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

NFData a => NFData (Max a)

Defined in Data.Semiring

Methods

rnf :: Max a -> ()

(Semiring a, Ord a, HasNegativeInfinity a) => DetectableZero (Max a)

Defined in Data.Semiring

Methods

isZero :: Max a -> Bool

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Max a)

Defined in Data.Semiring

Methods

star :: Max a -> Max a

plus :: Max a -> Max a

(Semiring a, Ord a, HasNegativeInfinity a) => Semiring (Max a)

Defined in Data.Semiring

Methods

zero :: Max a

one :: Max a

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

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

add :: [Max a] -> Max a

mul :: [Max a] -> Max a

Generic1 Max

Defined in Data.Semiring

Associated Types

type Rep1 Max :: k -> Type

Methods

from1 :: Max a -> Rep1 Max a

to1 :: Rep1 Max a -> Max a

newtype MVector s (Max a)

Defined in Data.Semiring

newtype MVector s (Max a) = MV_Max (MVector s a)

type Rep (Max a)

Defined in Data.Semiring

type Rep (Max a) = D1 (MetaData "Max" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Max" PrefixI True) (S1 (MetaSel (Just "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Vector (Max a)

Defined in Data.Semiring

newtype Vector (Max a) = V_Max (Vector a)

type Rep1 Max

Defined in Data.Semiring

type Rep1 Max = D1 (MetaData "Max" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Max" PrefixI True) (S1 (MetaSel (Just "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Min a

The "Tropical" or min-plus semiring. It is a semiring where:

<+>  = min
zero = ∞
<.>  = <+>
one  = zero

Note that we can't use Min from Semigroup because annihilation needs to hold:

∞ <+> x = x <+> ∞ = ∞

Taking ∞ to be maxBound would break the above law. Using positiveInfinity to represent it follows the law.

Constructors

Min

Fields

• getMin :: a

Instances

Functor Min

Defined in Data.Semiring

Methods

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

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

Foldable Min

Defined in Data.Semiring

Methods

fold :: Monoid m => Min m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Min a -> a

foldl1 :: (a -> a -> a) -> Min a -> a

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

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

maximum :: Ord a => Min a -> a

minimum :: Ord a => Min a -> a

sum :: Num a => Min a -> a

product :: Num a => Min a -> a

Traversable Min

Defined in Data.Semiring

Methods

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

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

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

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

Eq1 Min

Defined in Data.Semiring

Methods

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

Ord1 Min

Defined in Data.Semiring

Methods

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

Read1 Min

Defined in Data.Semiring

Methods

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

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

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Min a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Min a]

Show1 Min

Defined in Data.Semiring

Methods

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

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

Unbox a => Vector Vector (Min a)

Defined in Data.Semiring

Methods

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

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

basicLength :: Vector (Min a) -> Int

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

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

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

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

Unbox a => MVector MVector (Min a)

Defined in Data.Semiring

Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

Bounded a => Bounded (Min a)

Defined in Data.Semiring

Methods

minBound :: Min a

maxBound :: Min a

Enum a => Enum (Min a)

Defined in Data.Semiring

Methods

succ :: Min a -> Min a

pred :: Min a -> Min a

toEnum :: Int -> Min a

fromEnum :: Min a -> Int

enumFrom :: Min a -> [Min a]

enumFromThen :: Min a -> Min a -> [Min a]

enumFromTo :: Min a -> Min a -> [Min a]

enumFromThenTo :: Min a -> Min a -> Min a -> [Min a]

Eq a => Eq (Min a)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Min a)

Defined in Data.Semiring

Methods

(/) :: Min a -> Min a -> Min a

recip :: Min a -> Min a

fromRational :: Rational -> Min a

Num a => Num (Min a)

Defined in Data.Semiring

Methods

(+) :: Min a -> Min a -> Min a

(-) :: Min a -> Min a -> Min a

(*) :: Min a -> Min a -> Min a

negate :: Min a -> Min a

abs :: Min a -> Min a

signum :: Min a -> Min a

fromInteger :: Integer -> Min a

Ord a => Ord (Min a)

Defined in Data.Semiring

Methods

compare :: Min a -> Min a -> Ordering

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

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

(>) :: Min a -> Min a -> Bool

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

max :: Min a -> Min a -> Min a

min :: Min a -> Min a -> Min a

Read a => Read (Min a)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Min a)

readList :: ReadS [Min a]

readPrec :: ReadPrec (Min a)

readListPrec :: ReadPrec [Min a]

Real a => Real (Min a)

Defined in Data.Semiring

Methods

toRational :: Min a -> Rational

RealFrac a => RealFrac (Min a)

Defined in Data.Semiring

Methods

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

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

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

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

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

Show a => Show (Min a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Generic (Min a)

Defined in Data.Semiring

Associated Types

type Rep (Min a) :: Type -> Type

Methods

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

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

Ord a => Semigroup (Min a)

Defined in Data.Semiring

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

(Ord a, HasPositiveInfinity a) => Monoid (Min a)

>>> (getMin . foldMap Min) [1..10]
1.0

Defined in Data.Semiring

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

Storable a => Storable (Min a)

Defined in Data.Semiring

Methods

sizeOf :: Min a -> Int

alignment :: Min a -> Int

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

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

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

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

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

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

NFData a => NFData (Min a)

Defined in Data.Semiring

Methods

rnf :: Min a -> ()

(Semiring a, Ord a, HasPositiveInfinity a) => DetectableZero (Min a)

Defined in Data.Semiring

Methods

isZero :: Min a -> Bool

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Min a)

Defined in Data.Semiring

Methods

star :: Min a -> Min a

plus :: Min a -> Min a

(Semiring a, Ord a, HasPositiveInfinity a) => Semiring (Min a)

Defined in Data.Semiring

Methods

zero :: Min a

one :: Min a

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

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

add :: [Min a] -> Min a

mul :: [Min a] -> Min a

Generic1 Min

Defined in Data.Semiring

Associated Types

type Rep1 Min :: k -> Type

Methods

from1 :: Min a -> Rep1 Min a

to1 :: Rep1 Min a -> Min a

newtype MVector s (Min a)

Defined in Data.Semiring

newtype MVector s (Min a) = MV_Min (MVector s a)

type Rep (Min a)

Defined in Data.Semiring

type Rep (Min a) = D1 (MetaData "Min" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Min" PrefixI True) (S1 (MetaSel (Just "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Vector (Min a)

Defined in Data.Semiring

newtype Vector (Min a) = V_Min (Vector a)

type Rep1 Min

Defined in Data.Semiring

type Rep1 Min = D1 (MetaData "Min" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Min" PrefixI True) (S1 (MetaSel (Just "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

Matrix wrapper

newtype Matrix f g a

A suitable definition of a square matrix for certain types which are both Applicative and Traversable. For instance, given a type like so:

>>> :{
data Quad a = Quad a a a a deriving Show
instance Functor Quad where
    fmap f (Quad w x y z) = Quad (f w) (f x) (f y) (f z)
instance Applicative Quad where
    pure x = Quad x x x x
    Quad fw fx fy fz <*> Quad xw xx xy xz =
        Quad (fw xw) (fx xx) (fy xy) (fz xz)
instance Foldable Quad where
    foldr f b (Quad w x y z) = f w (f x (f y (f z b)))
instance Traversable Quad where
    traverse f (Quad w x y z) = Quad <$> f w <*> f x <*> f y <*> f z
:}

The newtype performs as you would expect:

>>> getMatrix one :: Quad (Quad Integer)
Quad (Quad 1 0 0 0) (Quad 0 1 0 0) (Quad 0 0 1 0) (Quad 0 0 0 1)

ZipLists are another type which works with this newtype:

>>> :{
let xs = (Matrix . ZipList . map ZipList) [[1,2],[3,4]]
    ys = (Matrix . ZipList . map ZipList) [[5,6],[7,8]]
in (map getZipList . getZipList . getMatrix) (xs <.> ys)
:}
[[19,22],[43,50]]

Constructors

Matrix

Fields

• getMatrix :: f (g a)

Instances

Functor f => Generic1 (Matrix f g :: Type -> Type)

Defined in Data.Semiring

Associated Types

type Rep1 (Matrix f g) :: k -> Type

Methods

from1 :: Matrix f g a -> Rep1 (Matrix f g) a

to1 :: Rep1 (Matrix f g) a -> Matrix f g a

(Functor f, Functor g) => Functor (Matrix f g)

Defined in Data.Semiring

Methods

fmap :: (a -> b) -> Matrix f g a -> Matrix f g b

(<$) :: a -> Matrix f g b -> Matrix f g a

(Applicative f, Applicative g) => Applicative (Matrix f g)

Defined in Data.Semiring

Methods

pure :: a -> Matrix f g a

(<*>) :: Matrix f g (a -> b) -> Matrix f g a -> Matrix f g b

liftA2 :: (a -> b -> c) -> Matrix f g a -> Matrix f g b -> Matrix f g c

(*>) :: Matrix f g a -> Matrix f g b -> Matrix f g b

(<*) :: Matrix f g a -> Matrix f g b -> Matrix f g a

(Foldable f, Foldable g) => Foldable (Matrix f g)

Defined in Data.Semiring

Methods

fold :: Monoid m => Matrix f g m -> m

foldMap :: Monoid m => (a -> m) -> Matrix f g a -> m

foldr :: (a -> b -> b) -> b -> Matrix f g a -> b

foldr' :: (a -> b -> b) -> b -> Matrix f g a -> b

foldl :: (b -> a -> b) -> b -> Matrix f g a -> b

foldl' :: (b -> a -> b) -> b -> Matrix f g a -> b

foldr1 :: (a -> a -> a) -> Matrix f g a -> a

foldl1 :: (a -> a -> a) -> Matrix f g a -> a

toList :: Matrix f g a -> [a]

null :: Matrix f g a -> Bool

length :: Matrix f g a -> Int

elem :: Eq a => a -> Matrix f g a -> Bool

maximum :: Ord a => Matrix f g a -> a

minimum :: Ord a => Matrix f g a -> a

sum :: Num a => Matrix f g a -> a

product :: Num a => Matrix f g a -> a

(Traversable f, Traversable g) => Traversable (Matrix f g)

Defined in Data.Semiring

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Matrix f g a -> f0 (Matrix f g b)

sequenceA :: Applicative f0 => Matrix f g (f0 a) -> f0 (Matrix f g a)

mapM :: Monad m => (a -> m b) -> Matrix f g a -> m (Matrix f g b)

sequence :: Monad m => Matrix f g (m a) -> m (Matrix f g a)

(Eq1 f, Eq1 g) => Eq1 (Matrix f g)

Defined in Data.Semiring

Methods

liftEq :: (a -> b -> Bool) -> Matrix f g a -> Matrix f g b -> Bool

(Ord1 f, Ord1 g) => Ord1 (Matrix f g)

Defined in Data.Semiring

Methods

liftCompare :: (a -> b -> Ordering) -> Matrix f g a -> Matrix f g b -> Ordering

(Read1 f, Read1 g) => Read1 (Matrix f g)

Defined in Data.Semiring

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Matrix f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Matrix f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Matrix f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Matrix f g a]

(Show1 f, Show1 g) => Show1 (Matrix f g)

Defined in Data.Semiring

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Matrix f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Matrix f g a] -> ShowS

(Eq1 f, Eq1 g, Eq a) => Eq (Matrix f g a)

Defined in Data.Semiring

Methods

(==) :: Matrix f g a -> Matrix f g a -> Bool

(/=) :: Matrix f g a -> Matrix f g a -> Bool

(Ord1 f, Ord1 g, Ord a) => Ord (Matrix f g a)

Defined in Data.Semiring

Methods

compare :: Matrix f g a -> Matrix f g a -> Ordering

(<) :: Matrix f g a -> Matrix f g a -> Bool

(<=) :: Matrix f g a -> Matrix f g a -> Bool

(>) :: Matrix f g a -> Matrix f g a -> Bool

(>=) :: Matrix f g a -> Matrix f g a -> Bool

max :: Matrix f g a -> Matrix f g a -> Matrix f g a

min :: Matrix f g a -> Matrix f g a -> Matrix f g a

(Read1 f, Read1 g, Read a) => Read (Matrix f g a)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Matrix f g a)

readList :: ReadS [Matrix f g a]

readPrec :: ReadPrec (Matrix f g a)

readListPrec :: ReadPrec [Matrix f g a]

(Show1 f, Show1 g, Show a) => Show (Matrix f g a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Matrix f g a -> ShowS

show :: Matrix f g a -> String

showList :: [Matrix f g a] -> ShowS

Generic (Matrix f g a)

Defined in Data.Semiring

Associated Types

type Rep (Matrix f g a) :: Type -> Type

Methods

from :: Matrix f g a -> Rep (Matrix f g a) x

to :: Rep (Matrix f g a) x -> Matrix f g a

(Traversable f, Applicative f, DetectableZero a, f ~ g) => DetectableZero (Matrix f g a)

Defined in Data.Semiring

Methods

isZero :: Matrix f g a -> Bool

(Traversable f, Applicative f, Semiring a, f ~ g) => Semiring (Matrix f g a)

Defined in Data.Semiring

Methods

zero :: Matrix f g a

one :: Matrix f g a

(<.>) :: Matrix f g a -> Matrix f g a -> Matrix f g a

(<+>) :: Matrix f g a -> Matrix f g a -> Matrix f g a

add :: [Matrix f g a] -> Matrix f g a

mul :: [Matrix f g a] -> Matrix f g a

type Rep1 (Matrix f g :: Type -> Type)

Defined in Data.Semiring

type Rep1 (Matrix f g :: Type -> Type) = D1 (MetaData "Matrix" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Matrix" PrefixI True) (S1 (MetaSel (Just "getMatrix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (f :.: Rec1 g)))

type Rep (Matrix f g a)

Defined in Data.Semiring

type Rep (Matrix f g a) = D1 (MetaData "Matrix" "Data.Semiring" "semiring-num-1.6.0.4-dekzUTTALSHxRzVbKMHCa" True) (C1 (MetaCons "Matrix" PrefixI True) (S1 (MetaSel (Just "getMatrix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f (g a)))))

transpose :: (Applicative g, Traversable f) => Matrix f g a -> Matrix g f a

Transpose the matrix.

mulMatrix :: (Applicative n, Traversable m, Applicative m, Applicative p, Semiring a) => n (m a) -> m (p a) -> n (p a)

Multiply two matrices.

rows :: (Foldable f, Foldable g) => Matrix f g a -> [[a]]

Convert the matrix to a nested list, in row-major form.

cols :: (Foldable f, Foldable g) => Matrix f g a -> [[a]]

Convert the matrix to a nested list, in column-major form.