Math.Algebra.Polynomial.Monomial.Indexed

Multivariate monomials where the variable set looks like {x_1, x_2, ... , x_N}

Monomials

newtype XS (var :: Symbol) (n :: Nat)

Monomials of the variables x1,x2,...,xn. The internal representation is the dense array of exponents: x1^e1*x2^e2*...*xn^en is represented by [e1,e2,...,en].

The type is indexed by the name of the variables, and then the number of variables.

Note that we require here that the array has bounds (1,n)

Constructors

XS (UArray Int Int)

Instances

Eq (XS var n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

(==) :: XS var n -> XS var n -> Bool

(/=) :: XS var n -> XS var n -> Bool

Ord (XS var n)

Note: this must be a monomial ordering!

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

compare :: XS var n -> XS var n -> Ordering

(<) :: XS var n -> XS var n -> Bool

(<=) :: XS var n -> XS var n -> Bool

(>) :: XS var n -> XS var n -> Bool

(>=) :: XS var n -> XS var n -> Bool

max :: XS var n -> XS var n -> XS var n

min :: XS var n -> XS var n -> XS var n

Show (XS var n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

showsPrec :: Int -> XS var n -> ShowS

show :: XS var n -> String

showList :: [XS var n] -> ShowS

KnownNat n => Semigroup (XS var n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

(<>) :: XS var n -> XS var n -> XS var n

sconcat :: NonEmpty (XS var n) -> XS var n

stimes :: Integral b => b -> XS var n -> XS var n

KnownNat n => Monoid (XS var n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

mempty :: XS var n

mappend :: XS var n -> XS var n -> XS var n

mconcat :: [XS var n] -> XS var n

KnownSymbol var => Pretty (XS var n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Methods

pretty :: XS var n -> String

prettyInParens :: XS var n -> String

(KnownNat n, KnownSymbol v) => Monomial (XS v n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

Associated Types

type VarM (XS v n) :: Type

Methods

normalizeM :: XS v n -> XS v n

isNormalM :: XS v n -> Bool

fromListM :: [(VarM (XS v n), Int)] -> XS v n

toListM :: XS v n -> [(VarM (XS v n), Int)]

emptyM :: XS v n

isEmptyM :: XS v n -> Bool

variableM :: VarM (XS v n) -> XS v n

singletonM :: VarM (XS v n) -> Int -> XS v n

mulM :: XS v n -> XS v n -> XS v n

productM :: [XS v n] -> XS v n

powM :: XS v n -> Int -> XS v n

divM :: XS v n -> XS v n -> Maybe (XS v n)

diffM :: Num c => VarM (XS v n) -> Int -> XS v n -> Maybe (XS v n, c)

maxDegM :: XS v n -> Int

totalDegM :: XS v n -> Int

evalM :: Num c => (VarM (XS v n) -> c) -> XS v n -> c

varSubsM :: (VarM (XS v n) -> VarM (XS v n)) -> XS v n -> XS v n

termSubsM :: Num c => (VarM (XS v n) -> Maybe c) -> (XS v n, c) -> (XS v n, c)

type VarM (XS v n)

Defined in Math.Algebra.Polynomial.Monomial.Indexed

type VarM (XS v n) = Index

xsVar :: KnownSymbol var => XS var n -> String

Name of the variables

nOfXS :: KnownNat n => XS var n -> Int

Number of variables

emptyness

emptyXS :: KnownNat n => XS v n

isEmptyXS :: XS v n -> Bool

normalization

isNormalXS :: KnownNat n => XS v n -> Bool

conversion

xsFromList :: KnownNat n => [(Index, Int)] -> XS v n

from (variable,exponent) pairs

xsToList :: XS v n -> [(Index, Int)]

to (variable,exponent) pairs

xsFromExponents :: KnownNat n => [Int] -> XS v n

from exponent list

xsToExponents :: KnownNat n => XS v n -> [Int]

to exponent list

creation

variableXS :: KnownNat n => Index -> XS v n

singletonXS :: KnownNat n => Index -> Int -> XS v n

multiplication

mulXS :: KnownNat n => XS v n -> XS v n -> XS v n

productXS :: (KnownNat n, Foldable f) => f (XS v n) -> XS v n

powXS :: XS v n -> Int -> XS v n

divXS :: KnownNat n => XS v n -> XS v n -> Maybe (XS v n)

degree

maxDegXS :: XS v n -> Int

totalDegXS :: XS v n -> Int

evaluation and substituion

evalXS :: Num c => (Index -> c) -> XS v n -> c

varSubsXS :: KnownNat n => (Index -> Index) -> XS v n -> XS v n

termSubsXS :: (KnownNat n, Num c) => (Index -> Maybe c) -> (XS v n, c) -> (XS v n, c)

differentiation

diffXS :: Num c => Index -> Int -> XS v n -> Maybe (XS v n, c)

changing the number of variables

embedXS :: (KnownNat n, KnownNat m) => XS v n -> XS v m

You can always increase the number of variables; you can also decrease, if don't use the last few ones.

This will throw an error if you try to eliminate variables which are in fact used. To do that, you can instead substitute 1 into them.