Text.PhonotacticLearner.Util.Ring

This module provides a hierarchy of typeclasses to describe rings and their substructures without all of the additional structure found in Num (which does not apply to most rings). Num instances are automatically Ring instances if no explicit instance is given, making Ring a drop-in replacenent for Num to make more generic functions.

A typeclass for algebraic modules (aka. vector spaces if over a field) is also included as well as a data type for the vector space ℝ[x]=ℝ∪ℝ²∪ℝ³∪… (usable for ℝⁿ although dimensions are not checked).

In order to not clash with Num or Arrow, this module uses the unicode circled operators '⊕', '⊖', '⊗', and '⊙'. If you are using XIM (Linux) or WinCompose, add the following lines to your .XCompose file:

<Multi_key> <r> <plus> : "⊕"
<Multi_key> <r> <period> : "⊙"
<Multi_key> <r> <asterisk> : "⊗"
<Multi_key> <r> <minus> : "⊖"

Rings

class Additive g where

Monoids with additive syntax

Minimal complete definition

zero, (⊕)

Methods

zero :: g

(⊕) :: g -> g -> g

Instances

Additive Bool

Methods

zero :: Bool

(⊕) :: Bool -> Bool -> Bool

Additive ()

Methods

zero :: ()

(⊕) :: () -> () -> ()

Num r => Additive r

Methods

zero :: r

(⊕) :: r -> r -> r

Additive Vec

Methods

zero :: Vec

(⊕) :: Vec -> Vec -> Vec

Additive r => Additive (RProd r)

Methods

zero :: RProd r

(⊕) :: RProd r -> RProd r -> RProd r

Additive r => Additive (RSum r)

Methods

zero :: RSum r

(⊕) :: RSum r -> RSum r -> RSum r

RingModule Double v => Additive (Expectation v)

Methods

zero :: Expectation v

(⊕) :: Expectation v -> Expectation v -> Expectation v

(Additive r, Additive s) => Additive (r, s)

Methods

zero :: (r, s)

(⊕) :: (r, s) -> (r, s) -> (r, s)

class Additive g => AdditiveGroup g where

Additive groups with inverses and suntraction

Minimal complete definition

addinv

Methods

addinv :: g -> g

(⊖) :: g -> g -> g

Instances

AdditiveGroup ()

Methods

addinv :: () -> ()

(⊖) :: () -> () -> ()

Num r => AdditiveGroup r

Methods

addinv :: r -> r

(⊖) :: r -> r -> r

AdditiveGroup Vec

Methods

addinv :: Vec -> Vec

(⊖) :: Vec -> Vec -> Vec

AdditiveGroup r => AdditiveGroup (RProd r)

Methods

addinv :: RProd r -> RProd r

(⊖) :: RProd r -> RProd r -> RProd r

AdditiveGroup r => AdditiveGroup (RSum r)

Methods

addinv :: RSum r -> RSum r

(⊖) :: RSum r -> RSum r -> RSum r

(AdditiveGroup r, AdditiveGroup s) => AdditiveGroup (r, s)

Methods

addinv :: (r, s) -> (r, s)

(⊖) :: (r, s) -> (r, s) -> (r, s)

class Additive r => Semiring r where

Semirings with addition and multiplication (but not subtraction).

Minimal complete definition

one, (⊗)

Methods

one :: r

(⊗) :: r -> r -> r

Instances

Semiring Bool

Methods

one :: Bool

(⊗) :: Bool -> Bool -> Bool

Semiring ()

Methods

one :: ()

(⊗) :: () -> () -> ()

Num r => Semiring r

Methods

one :: r

(⊗) :: r -> r -> r

Semiring r => Semiring (RProd r)

Methods

one :: RProd r

(⊗) :: RProd r -> RProd r -> RProd r

Semiring r => Semiring (RSum r)

Methods

one :: RSum r

(⊗) :: RSum r -> RSum r -> RSum r

RingModule Double v => Semiring (Expectation v)

Methods

one :: Expectation v

(⊗) :: Expectation v -> Expectation v -> Expectation v

(Semiring r, Semiring s) => Semiring (r, s)

Methods

one :: (r, s)

(⊗) :: (r, s) -> (r, s) -> (r, s)

class (Semiring r, AdditiveGroup r) => Ring r

Rings have both subtraction and multiplication

Instances

Ring ()

Num r => Ring r

Ring r => Ring (RProd r)

Ring r => Ring (RSum r)

(Ring r, Ring s) => Ring (r, s)

newtype RSum r

Monoid wrapper using addition, same as Sum

Constructors

RSum r

Instances

Eq r => Eq (RSum r)

Methods

(==) :: RSum r -> RSum r -> Bool

(/=) :: RSum r -> RSum r -> Bool

Ord r => Ord (RSum r)

Methods

compare :: RSum r -> RSum r -> Ordering

(<) :: RSum r -> RSum r -> Bool

(<=) :: RSum r -> RSum r -> Bool

(>) :: RSum r -> RSum r -> Bool

(>=) :: RSum r -> RSum r -> Bool

max :: RSum r -> RSum r -> RSum r

min :: RSum r -> RSum r -> RSum r

Show r => Show (RSum r)

Methods

showsPrec :: Int -> RSum r -> ShowS

show :: RSum r -> String

showList :: [RSum r] -> ShowS

Additive r => Monoid (RSum r)

Methods

mempty :: RSum r

mappend :: RSum r -> RSum r -> RSum r

mconcat :: [RSum r] -> RSum r

Ring r => Ring (RSum r)

Semiring r => Semiring (RSum r)

Methods

one :: RSum r

(⊗) :: RSum r -> RSum r -> RSum r

AdditiveGroup r => AdditiveGroup (RSum r)

Methods

addinv :: RSum r -> RSum r

(⊖) :: RSum r -> RSum r -> RSum r

Additive r => Additive (RSum r)

Methods

zero :: RSum r

(⊕) :: RSum r -> RSum r -> RSum r

newtype RProd r

Monoid wrapper using multiplication, same as Product

Constructors

RProd r

Instances

Eq r => Eq (RProd r)

Methods

(==) :: RProd r -> RProd r -> Bool

(/=) :: RProd r -> RProd r -> Bool

Ord r => Ord (RProd r)

Methods

compare :: RProd r -> RProd r -> Ordering

(<) :: RProd r -> RProd r -> Bool

(<=) :: RProd r -> RProd r -> Bool

(>) :: RProd r -> RProd r -> Bool

(>=) :: RProd r -> RProd r -> Bool

max :: RProd r -> RProd r -> RProd r

min :: RProd r -> RProd r -> RProd r

Show r => Show (RProd r)

Methods

showsPrec :: Int -> RProd r -> ShowS

show :: RProd r -> String

showList :: [RProd r] -> ShowS

Semiring r => Monoid (RProd r)

Methods

mempty :: RProd r

mappend :: RProd r -> RProd r -> RProd r

mconcat :: [RProd r] -> RProd r

Ring r => Ring (RProd r)

Semiring r => Semiring (RProd r)

Methods

one :: RProd r

(⊗) :: RProd r -> RProd r -> RProd r

AdditiveGroup r => AdditiveGroup (RProd r)

Methods

addinv :: RProd r -> RProd r

(⊖) :: RProd r -> RProd r -> RProd r

Additive r => Additive (RProd r)

Methods

zero :: RProd r

(⊕) :: RProd r -> RProd r -> RProd r

sumR :: (Foldable f, Additive r) => f r -> r

Fold using addition

productR :: (Foldable f, Semiring r) => f r -> r

Fold using multiplication

Modules and vectors

class (Ring r, AdditiveGroup v) => RingModule r v where

A module over a Ring r is an AdditiveGroup which can be multiplied by scalars in r.

Minimal complete definition

(⊙)

Methods

(⊙) :: r -> v -> v

Instances

RingModule Double Vec

Methods

(⊙) :: Double -> Vec -> Vec

RingModule Int Double

Since ℝ is a module over ℤ, using scalar multiplication can save a lot of coersion noise.

Methods

(⊙) :: Int -> Double -> Double

RingModule Int Vec

Methods

(⊙) :: Int -> Vec -> Vec

Ring r => RingModule r r

Every Ring is a module over itself.

Methods

(⊙) :: r -> r -> r

(RingModule r v, RingModule r w) => RingModule r (v, w)

Methods

(⊙) :: r -> (v, w) -> (v, w)

newtype Vec

Implements variable-length vectors. Addition batween vectors of different lengths occurs by letting ℝ⊆ℝ²⊆ℝ³⊆… by embedding each length in the space op polynomials.

Constructors

Vec

Fields

• unVec :: Vector Double

Instances

Eq Vec

Methods

(==) :: Vec -> Vec -> Bool

(/=) :: Vec -> Vec -> Bool

Read Vec

Methods

readsPrec :: Int -> ReadS Vec

readList :: ReadS [Vec]

readPrec :: ReadPrec Vec

readListPrec :: ReadPrec [Vec]

Show Vec

Methods

showsPrec :: Int -> Vec -> ShowS

show :: Vec -> String

showList :: [Vec] -> ShowS

NFData Vec

Methods

rnf :: Vec -> ()

AdditiveGroup Vec

Methods

addinv :: Vec -> Vec

(⊖) :: Vec -> Vec -> Vec

Additive Vec

Methods

zero :: Vec

(⊕) :: Vec -> Vec -> Vec

RingModule Double Vec

Methods

(⊙) :: Double -> Vec -> Vec

RingModule Int Vec

Methods

(⊙) :: Int -> Vec -> Vec

PackedDFA ExpVecDFST (Expectation Vec)

Methods

numStates :: Ix sigma => ExpVecDFST sigma -> Int

psegBounds :: Ix sigma => ExpVecDFST sigma -> (sigma, sigma)

unpackDFA :: Ix sigma => ExpVecDFST sigma -> DFST Int sigma (Expectation Vec)

packDFA :: Ix sigma => Int16 -> Int16 -> (sigma, sigma) -> ((Int16, sigma) -> Int16) -> ((Int16, sigma) -> Expectation Vec) -> (Int16 -> Expectation Vec) -> ExpVecDFST sigma

coords :: Vec -> [Double]

Returns a list of coordinates.

fromInts :: [Int] -> Vec

Convert from a list of integers.

vec :: [Double] -> Vec

Convert from a list of coordinates.

innerProd :: Vec -> Vec -> Double

Standard inner product on ℝⁿ.

normVec :: Vec -> Double

Calculate the euclidean norm of a vector.

normalizeVec :: Vec -> Vec

Return a vector of unit length pointing in the same direction.

consVec :: Double -> Vec -> Vec

Add a number to the begining of the list of coordinates.

l1Vec :: Vec -> Double

Taxicab norm.

dl1Vec :: Vec -> Vec

Gradient of taxicab norm.

showFVec :: Maybe Int -> Vec -> String

Show a vector to a certain precision, equivalent of showFFloat.