Safe Haskell | None |
---|---|

Language | Haskell98 |

A module defining the algebra of commutative polynomials over a field k.

Most users should probably use Math.CommutativeAlgebra.Polynomial instead, which is basically the same thing but more fully-featured. This module will probably be deprecated at some point, but remains for now because it has a simpler implementation which may be more helpful for people wanting to understand the code.

## Synopsis

- data GlexMonomial v = Glex Int [(v, Int)]
- type GlexPoly k v = Vect k (GlexMonomial v)
- glexVar :: Num k => v -> GlexPoly k v
- class Monomial m where
- bind :: (Monomial m, Eq k, Num k, Ord b, Show b, Algebra k b) => Vect k (m v) -> (v -> Vect k b) -> Vect k b
- lt :: Vect k b -> (b, k)
- class DivisionBasis b where
- dividesT :: DivisionBasis b1 => (b1, b2) -> (b1, b3) -> Bool
- divT :: (DivisionBasis a, Fractional b) => (a, b) -> (a, b) -> (a, b)
- quotRemMP :: (DivisionBasis b2, Fractional b1, Eq b1, Ord b2, Show b2, Algebra b1 b2) => Vect b1 b2 -> [Vect b1 b2] -> ([Vect b1 b2], Vect b1 b2)
- (%%) :: (Eq k, Fractional k, Ord b, Show b, Algebra k b, DivisionBasis b) => Vect k b -> [Vect k b] -> Vect k b

# Documentation

data GlexMonomial v Source #

## Instances

type GlexPoly k v = Vect k (GlexMonomial v) Source #

glexVar :: Num k => v -> GlexPoly k v Source #

glexVar creates a variable in the algebra of commutative polynomials with Glex term ordering. For example, the following code creates variables called x, y and z:

[x,y,z] = map glexVar ["x","y","z"] :: GlexPoly Q String

class Monomial m where Source #

## Instances

Monomial GlexMonomial Source # | |

Defined in Math.Algebras.Commutative | |

Monomial SL2 Source # | |

bind :: (Monomial m, Eq k, Num k, Ord b, Show b, Algebra k b) => Vect k (m v) -> (v -> Vect k b) -> Vect k b Source #

In effect, we have (Num k, Monomial m) => Monad (v -> Vect k (m v)), with return = var, and (>>=) = bind. However, we can't express this directly in Haskell, firstly because of the Ord b constraint, secondly because Haskell doesn't support type functions.

class DivisionBasis b where Source #

## Instances

Ord v => DivisionBasis (GlexMonomial v) Source # | |

Defined in Math.Algebras.Commutative dividesB :: GlexMonomial v -> GlexMonomial v -> Bool Source # divB :: GlexMonomial v -> GlexMonomial v -> GlexMonomial v Source # |

dividesT :: DivisionBasis b1 => (b1, b2) -> (b1, b3) -> Bool Source #

divT :: (DivisionBasis a, Fractional b) => (a, b) -> (a, b) -> (a, b) Source #