Math.Algebra.Hspray

Deals with multivariate polynomials over a commutative ring. See README for examples.

Classes

class FunctionLike b where

A spray represents a multivariate polynomial so it like a function. We introduce a class because it will be assigned to the ratios of sprays too.

Minimal complete definition

numberOfVariables, permuteVariables, swapVariables, involvesVariable, dropVariables, derivative, (*^), (+>), evaluate, substitute, changeVariables

Associated Types

type BaseRing b

The type of the coefficients (this is a for both Spray a and RatioOfSprays a)

type VariablesType b

The type of the variables (this is Spray a for both Spray a and RatioOfSprays a)

Methods

numberOfVariables :: b -> Int

Number of variables in a function-like object

permuteVariables

Arguments

:: [Int]

permutation

-> b

function-like object whose variables will be permuted

-> b

the function-like object with permuted variables

Permutes the variables of a function-like object

>>> f :: Spray Rational -> Spray Rational -> Spray Rational -> Spray Rational
>>> f p1 p2 p3 = p1^**^4 ^+^ (2*^p2^**^3) ^+^ (3*^p3^**^2) ^-^ (4*^unitSpray)
>>> x1 = lone 1 :: Spray Rational
>>> x2 = lone 2 :: Spray Rational
>>> x3 = lone 3 :: Spray Rational
>>> spray = f x1 x2 x3

permuteVariables [3, 1, 2] spray == f x3 x1 x2

swapVariables

Arguments

:: (Int, Int)

the indices of the variables to be swapped (starting at 1)

-> b

function-like object whose variables will be swapped

-> b

the function-like object with swapped variables

Swaps two variables of a function-like object

swapVariables (1, 3) x == permuteVariables [3, 2, 1] x

involvesVariable

Arguments

:: b

function-like object

-> Int

index of the variable

-> Bool

dropVariables

Arguments

:: Int

number of leading variables to drop

-> b

a function-like object

-> b

Drops a given number of leading variables in a function-like object; very unsafe, dropVariables n x should not be used if involvesVariable x i is True for some i in 1, ... n

dropVariables 1 (qlone 2 ^+^ qlone 3) == qlone 1 ^+^ qlone 2

derivative

Arguments

:: Int

index of the variable of differentiation (starting at 1)

-> b

the object to be derivated

-> b

the derivated object

Derivative of a function-like object

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> spray = 2*^x ^-^ 3*^y^**^8
>>> spray' = derivative 1 spray
>>> putStrLn $ prettyNumSpray spray'
2

(^+^) :: C b => b -> b -> b infixl 6

Addition of two function-like objects

(^-^) :: C b => b -> b -> b infixl 6

Substraction of two function-like objects

(^*^) :: C b => b -> b -> b infixl 7

Multiplication of two function-like objects

(^**^) :: C b => b -> Int -> b infixr 8

Power of a function-like object

(*^) :: BaseRing b -> b -> b infixr 7

Multiply a function-like object by a scalar

(+>) :: BaseRing b -> b -> b infixl 6

Add a function-like object to a constant

x +> spray == constantSpray x ^+^ spray

(<+) :: b -> BaseRing b -> b infixr 6

Add a constant to a function-like object

object <+ x == x +> object

evaluate

Arguments

:: b

function-like object to be evaluated, e.g. a spray

-> [BaseRing b]

list of values to be substituted to its variables

-> BaseRing b

Evaluation (replacing the variables with some values) of a function-like object

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> spray = 2*^x^**^2 ^-^ 3*^y
>>> evaluate spray [2, 1]
5

evaluateAt :: [BaseRing b] -> b -> BaseRing b

Flipped version of evaluate

evaluateAt [2, 1] spray == evaluate spray [2, 1]

substitute

Arguments

:: [Maybe (BaseRing b)]

Just x to replace the variable with x, Nothing for no replacement

-> b

function-like object to be partially evaluated

-> b

Partial evaluation of a function-like object (replace some variables with some values)

>>> x1 = lone 1 :: Spray Int
>>> x2 = lone 2 :: Spray Int
>>> x3 = lone 3 :: Spray Int
>>> spray = x1^**^2 ^-^ x2 ^+^ x3 ^-^ unitSpray
>>> spray' = substitute [Just 2, Nothing, Just 3] spray
>>> putStrLn $ prettyNumSprayX1X2X3 "x" spray'
-x2 + 6 

changeVariables

Arguments

:: b

function-like object such as a spray

-> [VariablesType b]

list of new variables

-> b

Polynomial change of variables of a function-like object

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> spray = x ^*^ y
>>> spray' = changeVariables spray [x ^+^ y, x ^-^ y]
>>> putStrLn $ prettyNumSpray' spray'
X^2 - Y^2

Instances

(Eq a, C a) => FunctionLike (Polynomial a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (Polynomial a)

type VariablesType (Polynomial a)

Methods

numberOfVariables :: Polynomial a -> Int

permuteVariables :: [Int] -> Polynomial a -> Polynomial a

swapVariables :: (Int, Int) -> Polynomial a -> Polynomial a

involvesVariable :: Polynomial a -> Int -> Bool

dropVariables :: Int -> Polynomial a -> Polynomial a

derivative :: Int -> Polynomial a -> Polynomial a

(^+^) :: Polynomial a -> Polynomial a -> Polynomial a

(^-^) :: Polynomial a -> Polynomial a -> Polynomial a

(^*^) :: Polynomial a -> Polynomial a -> Polynomial a

(^**^) :: Polynomial a -> Int -> Polynomial a

(*^) :: BaseRing (Polynomial a) -> Polynomial a -> Polynomial a

(+>) :: BaseRing (Polynomial a) -> Polynomial a -> Polynomial a

(<+) :: Polynomial a -> BaseRing (Polynomial a) -> Polynomial a

evaluate :: Polynomial a -> [BaseRing (Polynomial a)] -> BaseRing (Polynomial a)

evaluateAt :: [BaseRing (Polynomial a)] -> Polynomial a -> BaseRing (Polynomial a)

substitute :: [Maybe (BaseRing (Polynomial a))] -> Polynomial a -> Polynomial a

changeVariables :: Polynomial a -> [VariablesType (Polynomial a)] -> Polynomial a

(Eq a, C a) => FunctionLike (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (RatioOfPolynomials a)

type VariablesType (RatioOfPolynomials a)

Methods

numberOfVariables :: RatioOfPolynomials a -> Int

permuteVariables :: [Int] -> RatioOfPolynomials a -> RatioOfPolynomials a

swapVariables :: (Int, Int) -> RatioOfPolynomials a -> RatioOfPolynomials a

involvesVariable :: RatioOfPolynomials a -> Int -> Bool

dropVariables :: Int -> RatioOfPolynomials a -> RatioOfPolynomials a

derivative :: Int -> RatioOfPolynomials a -> RatioOfPolynomials a

(^+^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^-^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^*^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^**^) :: RatioOfPolynomials a -> Int -> RatioOfPolynomials a

(*^) :: BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a -> RatioOfPolynomials a

(+>) :: BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a -> RatioOfPolynomials a

(<+) :: RatioOfPolynomials a -> BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a

evaluate :: RatioOfPolynomials a -> [BaseRing (RatioOfPolynomials a)] -> BaseRing (RatioOfPolynomials a)

evaluateAt :: [BaseRing (RatioOfPolynomials a)] -> RatioOfPolynomials a -> BaseRing (RatioOfPolynomials a)

substitute :: [Maybe (BaseRing (RatioOfPolynomials a))] -> RatioOfPolynomials a -> RatioOfPolynomials a

changeVariables :: RatioOfPolynomials a -> [VariablesType (RatioOfPolynomials a)] -> RatioOfPolynomials a

(Eq a, C a) => FunctionLike (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (RatioOfSprays a)

type VariablesType (RatioOfSprays a)

Methods

numberOfVariables :: RatioOfSprays a -> Int

permuteVariables :: [Int] -> RatioOfSprays a -> RatioOfSprays a

swapVariables :: (Int, Int) -> RatioOfSprays a -> RatioOfSprays a

involvesVariable :: RatioOfSprays a -> Int -> Bool

dropVariables :: Int -> RatioOfSprays a -> RatioOfSprays a

derivative :: Int -> RatioOfSprays a -> RatioOfSprays a

(^+^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^-^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^*^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^**^) :: RatioOfSprays a -> Int -> RatioOfSprays a

(*^) :: BaseRing (RatioOfSprays a) -> RatioOfSprays a -> RatioOfSprays a

(+>) :: BaseRing (RatioOfSprays a) -> RatioOfSprays a -> RatioOfSprays a

(<+) :: RatioOfSprays a -> BaseRing (RatioOfSprays a) -> RatioOfSprays a

evaluate :: RatioOfSprays a -> [BaseRing (RatioOfSprays a)] -> BaseRing (RatioOfSprays a)

evaluateAt :: [BaseRing (RatioOfSprays a)] -> RatioOfSprays a -> BaseRing (RatioOfSprays a)

substitute :: [Maybe (BaseRing (RatioOfSprays a))] -> RatioOfSprays a -> RatioOfSprays a

changeVariables :: RatioOfSprays a -> [VariablesType (RatioOfSprays a)] -> RatioOfSprays a

(C a, Eq a) => FunctionLike (Spray a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (Spray a)

type VariablesType (Spray a)

Methods

numberOfVariables :: Spray a -> Int

permuteVariables :: [Int] -> Spray a -> Spray a

swapVariables :: (Int, Int) -> Spray a -> Spray a

involvesVariable :: Spray a -> Int -> Bool

dropVariables :: Int -> Spray a -> Spray a

derivative :: Int -> Spray a -> Spray a

(^+^) :: Spray a -> Spray a -> Spray a

(^-^) :: Spray a -> Spray a -> Spray a

(^*^) :: Spray a -> Spray a -> Spray a

(^**^) :: Spray a -> Int -> Spray a

(*^) :: BaseRing (Spray a) -> Spray a -> Spray a

(+>) :: BaseRing (Spray a) -> Spray a -> Spray a

(<+) :: Spray a -> BaseRing (Spray a) -> Spray a

evaluate :: Spray a -> [BaseRing (Spray a)] -> BaseRing (Spray a)

evaluateAt :: [BaseRing (Spray a)] -> Spray a -> BaseRing (Spray a)

substitute :: [Maybe (BaseRing (Spray a))] -> Spray a -> Spray a

changeVariables :: Spray a -> [VariablesType (Spray a)] -> Spray a

isConstant :: FunctionLike b => b -> Bool

Whether a function-like object has a constant value

isUnivariate :: FunctionLike b => b -> Bool

Whether a function-like object represents an univariate function; it is considered that it is univariate if it is constant

isBivariate :: FunctionLike b => b -> Bool

Whether a function-like object represents a bivariate function; it is considered that it is bivariate if it is univariate

isTrivariate :: FunctionLike b => b -> Bool

Whether a function-like object represents a trivariate function; it is considered that it is trivariate if it is bivariate

Main types

type Exponents = Seq Int

data Powers

The type Powers is used to represent the exponents of the monomial occurring in a term of a spray. The integer in the field nvariables is the number of variables involved in this monomial (it is 3, not 2, for a monomial such as x^2.z^3, because the exponents of this monomial is the sequence (2, 0, 3)). Actually this integer is always the length of the sequence in the field exponents. The reason of the presence of the field nvariables is that I thought that it was necessary when I started to develop the package, but now I think it is useless. The type Powers will possibly be abandoned in a future version of the package. However we cannot simply use the type Exponents to represent the exponents, because two sequences of exponents that differ only by some trailing zeros must be considered as identical, and they are considered as such with the type Powers thanks to its Eq instance. Instead of Powers, a new type encapsulating the Exponents type with such an Eq instance should be enough to represent the exponents.

Constructors

Powers

Fields

• exponents :: Exponents
• nvariables :: Int

Instances

Show Powers

Defined in Math.Algebra.Hspray

Methods

showsPrec :: Int -> Powers -> ShowS

show :: Powers -> String

showList :: [Powers] -> ShowS

Eq Powers

Defined in Math.Algebra.Hspray

Methods

(==) :: Powers -> Powers -> Bool

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

Hashable Powers

Defined in Math.Algebra.Hspray

Methods

hashWithSalt :: Int -> Powers -> Int

hash :: Powers -> Int

(Eq a, C a) => C a (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> OneParameterSpray a -> OneParameterSpray a

(Eq a, C a) => C a (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> ParametricSpray a -> ParametricSpray a

(Eq a, C a) => C a (SimpleParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> SimpleParametricSpray a -> SimpleParametricSpray a

(C a, Eq a) => C a (Spray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> Spray a -> Spray a

(Eq a, C a) => C a (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: OneParameterSpray a -> a -> OneParameterSpray a

(Eq a, C a) => C a (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: ParametricSpray a -> a -> ParametricSpray a

(Eq a, C a) => C a (SimpleParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: SimpleParametricSpray a -> a -> SimpleParametricSpray a

(C a, Eq a) => C a (Spray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: Spray a -> a -> Spray a

(C a, Eq a) => FunctionLike (Spray a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (Spray a)

type VariablesType (Spray a)

Methods

numberOfVariables :: Spray a -> Int

permuteVariables :: [Int] -> Spray a -> Spray a

swapVariables :: (Int, Int) -> Spray a -> Spray a

involvesVariable :: Spray a -> Int -> Bool

dropVariables :: Int -> Spray a -> Spray a

derivative :: Int -> Spray a -> Spray a

(^+^) :: Spray a -> Spray a -> Spray a

(^-^) :: Spray a -> Spray a -> Spray a

(^*^) :: Spray a -> Spray a -> Spray a

(^**^) :: Spray a -> Int -> Spray a

(*^) :: BaseRing (Spray a) -> Spray a -> Spray a

(+>) :: BaseRing (Spray a) -> Spray a -> Spray a

(<+) :: Spray a -> BaseRing (Spray a) -> Spray a

evaluate :: Spray a -> [BaseRing (Spray a)] -> BaseRing (Spray a)

evaluateAt :: [BaseRing (Spray a)] -> Spray a -> BaseRing (Spray a)

substitute :: [Maybe (BaseRing (Spray a))] -> Spray a -> Spray a

changeVariables :: Spray a -> [VariablesType (Spray a)] -> Spray a

(C a, Eq a) => C (Spray a)

Defined in Math.Algebra.Hspray

Methods

zero :: Spray a

(+) :: Spray a -> Spray a -> Spray a

(-) :: Spray a -> Spray a -> Spray a

negate :: Spray a -> Spray a

(C a, Eq a) => C (Spray a)

Defined in Math.Algebra.Hspray

Methods

(*) :: Spray a -> Spray a -> Spray a

one :: Spray a

fromInteger :: Integer -> Spray a

(^) :: Spray a -> Integer -> Spray a

(Eq a, C a) => C (Polynomial a) (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Polynomial a -> OneParameterSpray a -> OneParameterSpray a

(Eq a, C a) => C (Spray a) (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Spray a -> ParametricSpray a -> ParametricSpray a

(C a, Eq a) => C (Spray a) (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Spray a -> RatioOfSprays a -> RatioOfSprays a

(Eq a, C a) => C (Polynomial a) (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: OneParameterSpray a -> Polynomial a -> OneParameterSpray a

(Eq a, C a) => C (Spray a) (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: ParametricSpray a -> Spray a -> ParametricSpray a

(C a, Eq a) => C (Spray a) (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfSprays a -> Spray a -> RatioOfSprays a

type BaseRing (Spray a)

Defined in Math.Algebra.Hspray

type BaseRing (Spray a) = a

type VariablesType (Spray a)

Defined in Math.Algebra.Hspray

type VariablesType (Spray a) = Spray a

type Spray a = HashMap Powers a

An object of type Spray a represents a multivariate polynomial whose coefficients are represented by the objects of type a, which must have a ring instance in order that we can add and multiply two polynomials.

type QSpray = Spray Rational

Most often, one deals with sprays with rational coefficients, so we dedicate a type alias for such sprays.

type QSpray' = Spray Rational'

The type Rational' is helpful when dealing with OneParameterSpray sprays, but this type of sprays lost its interest in version 0.4.0.0 (see CHANGELOG or README).

type Term a = (Powers, a)

Basic sprays

lone :: C a => Int -> Spray a

The n-th polynomial variable x_n as a spray; one usually builds a spray by introducing these variables and combining them with the arithmetic operations

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> spray = 2*^x^**^2 ^-^ 3*^y
>>> putStrLn $ prettyNumSpray spray
2*x^2 - 3*y

lone 0 == unitSpray

qlone :: Int -> QSpray

The n-th polynomial variable for rational sprays; this is just a specialization of lone

lone'

Arguments

:: C a

=> Int

index

-> Int

exponent

-> Spray a

The spray x_n^p; more efficient than exponentiating lone n

lone' 2 10 = lone 2 ^**^ 10

qlone'

Arguments

:: Int

index

-> Int

exponent

-> QSpray

The rational spray x_n^p

monomial

Arguments

:: C a

=> [(Int, Int)]

list of (index, exponent); duplicates are deleted

-> Spray a

Monomial spray, e.g. monomial [(1,4),(3,2)] is x^4.z^2; indices and exponents must be positive but this is not checked prop> monomial [(1, 4), (3, 2)] == (lone 1 ^**^ 4) ^*^ (lone 3 ^**^ 2)

qmonomial :: [(Int, Int)] -> QSpray

Monomial rational spray, a specialization of monomial

qmonomial [(1, 4), (3, 2)] == (qlone 1 ^**^ 4) ^*^ (qlone 3 ^**^ 2)

unitSpray :: C a => Spray a

The unit spray

spray ^*^ unitSpray == spray

zeroSpray :: (Eq a, C a) => Spray a

The null spray

spray ^+^ zeroSpray == spray

constantSpray :: (Eq a, C a) => a -> Spray a

Constant spray

constantSpray 3 == 3 *^ unitSpray

Showing a spray

prettySpray :: Show a => Spray a -> String

Pretty form of a spray with monomials displayed in the style of "x.z^2"; you should rather use prettyNumSpray or prettyQSpray if you deal with sprays with numeric coefficients

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettySpray p
(2)*x + (3)*y^2 + (-4)*z^3
>>> putStrLn $ prettySpray (p ^+^ lone 4)
(2)*x1 + (3)*x2^2 + (-4)*x3^3 + x4

prettySpray spray == prettySprayXYZ ["x", "y", "z"] spray

prettySpray' :: Show a => Spray a -> String

Pretty form of a spray, with monomials shown as "x1.x3^2"; use prettySprayX1X2X3 to change the letter (or prettyNumSprayX1X2X3 or prettyQSprayX1X2X3 if the coefficients are numeric)

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettySpray' p
(2)*x1 + (3)*x2^2 + (-4)*x3^3 

prettySpray''

Arguments

:: Show a

=> String

a string denoting the variables, e.g. "x"

-> Spray a

the spray

-> String

Pretty form of a spray; you will probably prefer prettySpray or prettySpray'

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettySpray'' "x" p
(2)*x^(1) + (3)*x^(0, 2) + (-4)*x^(0, 0, 3)

prettySprayXYZ

Arguments

:: Show a

=> [String]

typically some letters, to print the variables

-> Spray a

the spray to be printed

-> String

Pretty form of a spray with monomials displayed in the style of "x.z^2"; you should rather use prettyNumSprayXYZ or prettyQSprayXYZ if your coefficients are numeric

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettySprayXYZ ["X", "Y", "Z"] p
(2)*X + (3)*Y^2 + (-4)*Z^3
>>> putStrLn $ prettySprayXYZ ["X", "Y"] p
(2)*X1 + (3)*X2^2 + (-4)*X3^3

prettySprayX1X2X3

Arguments

:: Show a

=> String

typically a letter, to print the non-indexed variables

-> Spray a

the spray to be printed

-> String

Pretty form of a spray with monomials displayed in the style of "x1.x3^2"; you should rather use prettyNumSprayX1X2X3 or prettyQSprayX1X2X3 if your coefficients are numeric

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> spray = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettySprayX1X2X3 "X" spray
(2)*X1 + (3)*X2^2 + (-4)*X3^3

showSpray

Arguments

:: (a -> String)

function mapping a coefficient to a string, typically show

-> (String, String)

pair of braces to enclose the coefficients

-> ([Exponents] -> [String])

function mapping a list of exponents to a list of strings representing the monomials corresponding to these exponents

-> Spray a

the spray to be printed

-> String

Prints a spray; this function is exported for possible usage in other packages

showSprayXYZ

Arguments

:: (a -> String)

function mapping a coefficient to a string, typically show

-> (String, String)

used to enclose the coefficients, usually a pair of braces

-> [String]

typically some letters, to print the variables

-> Spray a

the spray to be printed

-> String

Prints a spray, with monomials shown as "x.z^2", and with a user-defined showing function for the coefficients

showSprayXYZ'

Arguments

:: (a -> String)

function mapping a coefficient to a string, typically show

-> [String]

typically some letters, to print the variables

-> Spray a

the spray to be printed

-> String

Prints a spray, with monomials shown as "x.z^2", and with a user-defined showing function for the coefficients; this is the same as the function showSprayXYZ with the pair of braces ("(", ")")

showSprayX1X2X3

Arguments

:: (a -> String)

function mapping a coefficient to a string, typically show

-> (String, String)

used to enclose the coefficients

-> String

typically a letter, to print the non-indexed variables

-> Spray a

the spray to be printed

-> String

Pretty form of a spray, with monomials shown as "x1.x3^2", and with a user-defined showing function for the coefficients

showSprayX1X2X3'

Arguments

:: (a -> String)

function mapping a coefficient to a string, e.g. show

-> String

typically a letter, to print the non-indexed variables

-> Spray a

the spray to be printed

-> String

Pretty form of a spray, with monomials shown as "x1.x3^2", and with a user-defined showing function for the coefficients; this is the same as the function showSprayX1X2X3 with the pair of braces ("(", ")") used to enclose the coefficients

showNumSpray

Arguments

:: (Num a, Ord a)

=> ([Exponents] -> [String])

function mapping a list of monomial exponents to a list of strings representing the monomials

-> (a -> String)

function mapping a positive coefficient to a string

-> Spray a

-> String

Show a spray with numeric coefficients; this function is exported for possible usage in other packages

showQSpray

Arguments

:: ([Exponents] -> [String])

function printing monomials

-> QSpray

-> String

Prints a QSpray; for internal usage but exported for usage in other packages

showQSpray'

Arguments

:: ([Exponents] -> [String])

function mapping a list of monomials exponents to a list of strings

-> QSpray'

-> String

Prints a QSpray'; for internal usage but exported for usage in other packages

prettyNumSprayX1X2X3

Arguments

:: (Num a, Ord a, Show a)

=> String

usually a letter such as "x" to denote the non-indexed variables

-> Spray a

-> String

Pretty form of a spray with numeric coefficients, printing monomials as "x1.x3^2"

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettyNumSprayX1X2X3 "x" p
2*x1 + 3*x2^2 - 4*x3^3 

prettyQSprayX1X2X3

Arguments

:: String

usually a letter such as "x", to denote the non-indexed variables

-> QSpray

-> String

Pretty form of a spray with rational coefficients, printing monomials in the style of "x1.x3^2"

>>> x = lone 1 :: QSpray
>>> y = lone 2 :: QSpray
>>> z = lone 3 :: QSpray
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ (4%3)*^z^**^3
>>> putStrLn $ prettyQSprayX1X2X3 "x" p
2*x1 + 3*x2^2 - (4/3)*x3^3 

prettyQSprayX1X2X3'

Arguments

:: String

usually a letter such as "x", to denote the non-indexed variables

-> QSpray'

-> String

Same as prettyQSprayX1X2X3 but for a QSpray' spray

prettyNumSprayXYZ

Arguments

:: (Num a, Ord a, Show a)

=> [String]

usually some letters, denoting the variables

-> Spray a

-> String

Pretty form of a spray with numeric coefficients, printing monomials as "x.z^2" if possible, i.e. if enough letters are provided, otherwise as "x1.x3^2"

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> w = lone 4 :: Spray Int
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ 4*^z^**^3
>>> putStrLn $ prettyNumSprayXYZ ["x","y","z"] p
2*x + 3*y^2 - 4*z^3 
>>> putStrLn $ prettyNumSprayXYZ ["x","y","z"] (p ^+^ w)
2*x1 + 3*x2^2 - 4*x3^3 + x4
>>> putStrLn $ prettyNumSprayXYZ ["a","b","c"] (p ^+^ w)
2*a1 + 3*a2^2 - 4*a3^3 + a4

prettyQSprayXYZ

Arguments

:: [String]

usually some letters, to denote the variables

-> QSpray

-> String

Pretty form of a spray with rational coefficients, printing monomials in the style of "x.z^2" with the provided letters if possible, i.e. if enough letters are provided, otherwise in the style "x1.x3^2", taking the first provided letter to denote the non-indexed variables

>>> x = lone 1 :: QSpray
>>> y = lone 2 :: QSpray
>>> z = lone 3 :: QSpray
>>> p = 2*^x ^+^ 3*^y^**^2 ^-^ (4%3)*^z^**^3
>>> putStrLn $ prettyQSprayXYZ ["x","y","z"] p
2*x + 3*y^2 - (4/3)*z^3 
>>> putStrLn $ prettyQSprayXYZ ["x","y"] p
2*x1 + 3*x2^2 - (4%3)*x3^3
>>> putStrLn $ prettyQSprayXYZ ["a","b"] p
2*a1 + 3*a2^2 - (4/3)*a3^3

prettyQSprayXYZ'

Arguments

:: [String]

usually some letters, to denote the variables

-> QSpray'

-> String

Same as prettyQSprayXYZ but for a QSpray' spray

prettyNumSpray :: (Num a, Ord a, Show a) => Spray a -> String

Pretty printing of a spray with numeric coefficients prop> prettyNumSpray == prettyNumSprayXYZ ["x", "y", "z"]

prettyNumSpray' :: (Num a, Ord a, Show a) => Spray a -> String

Pretty printing of a spray with numeric coefficients prop> prettyNumSpray' == prettyNumSprayXYZ [X, Y, Z]

prettyQSpray :: QSpray -> String

Pretty printing of a spray with rational coefficients prop> prettyQSpray == prettyQSprayXYZ ["x", "y", "z"]

prettyQSpray'' :: QSpray -> String

Pretty printing of a spray with rational coefficients prop> prettyQSpray'' == prettyQSprayXYZ [X, Y, Z]

prettyQSpray' :: QSpray' -> String

Pretty printing of a spray with rational coefficients prop> prettyQSpray' == prettyQSprayXYZ' ["x", "y", "z"]

prettyQSpray''' :: QSpray' -> String

Pretty printing of a spray with rational coefficients prop> prettyQSpray''' == prettyQSprayXYZ' [X, Y, Z]

Univariate polynomials and fractions of univariate polynomials

The univariate polynomials and the fractions of univariate polynomials are used to defined the OneParameterSpray sprays, which represent multivariate polynomials depending on a unique parameter. These sprays lost their interest in version 0.4.0.0 (see CHANGELOG or README).

newtype A a

The new type A a is used to attribute some instances to the type Polynomial a; it is needed to avoid orphan instances.

Constructors

A a

Instances

(Eq a, C a) => C a (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> OneParameterSpray a -> OneParameterSpray a

(Eq a, C a) => C a (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> RatioOfPolynomials a -> RatioOfPolynomials a

(Eq a, C a) => C a (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: OneParameterSpray a -> a -> OneParameterSpray a

(Eq a, C a) => C a (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfPolynomials a -> a -> RatioOfPolynomials a

Show a => Show (A a)

Defined in Math.Algebra.Hspray

Methods

showsPrec :: Int -> A a -> ShowS

show :: A a -> String

showList :: [A a] -> ShowS

Eq a => Eq (A a)

Defined in Math.Algebra.Hspray

Methods

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

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

(Eq a, C a) => FunctionLike (Polynomial a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (Polynomial a)

type VariablesType (Polynomial a)

Methods

numberOfVariables :: Polynomial a -> Int

permuteVariables :: [Int] -> Polynomial a -> Polynomial a

swapVariables :: (Int, Int) -> Polynomial a -> Polynomial a

involvesVariable :: Polynomial a -> Int -> Bool

dropVariables :: Int -> Polynomial a -> Polynomial a

derivative :: Int -> Polynomial a -> Polynomial a

(^+^) :: Polynomial a -> Polynomial a -> Polynomial a

(^-^) :: Polynomial a -> Polynomial a -> Polynomial a

(^*^) :: Polynomial a -> Polynomial a -> Polynomial a

(^**^) :: Polynomial a -> Int -> Polynomial a

(*^) :: BaseRing (Polynomial a) -> Polynomial a -> Polynomial a

(+>) :: BaseRing (Polynomial a) -> Polynomial a -> Polynomial a

(<+) :: Polynomial a -> BaseRing (Polynomial a) -> Polynomial a

evaluate :: Polynomial a -> [BaseRing (Polynomial a)] -> BaseRing (Polynomial a)

evaluateAt :: [BaseRing (Polynomial a)] -> Polynomial a -> BaseRing (Polynomial a)

substitute :: [Maybe (BaseRing (Polynomial a))] -> Polynomial a -> Polynomial a

changeVariables :: Polynomial a -> [VariablesType (Polynomial a)] -> Polynomial a

(Eq a, C a) => FunctionLike (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (RatioOfPolynomials a)

type VariablesType (RatioOfPolynomials a)

Methods

numberOfVariables :: RatioOfPolynomials a -> Int

permuteVariables :: [Int] -> RatioOfPolynomials a -> RatioOfPolynomials a

swapVariables :: (Int, Int) -> RatioOfPolynomials a -> RatioOfPolynomials a

involvesVariable :: RatioOfPolynomials a -> Int -> Bool

dropVariables :: Int -> RatioOfPolynomials a -> RatioOfPolynomials a

derivative :: Int -> RatioOfPolynomials a -> RatioOfPolynomials a

(^+^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^-^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^*^) :: RatioOfPolynomials a -> RatioOfPolynomials a -> RatioOfPolynomials a

(^**^) :: RatioOfPolynomials a -> Int -> RatioOfPolynomials a

(*^) :: BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a -> RatioOfPolynomials a

(+>) :: BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a -> RatioOfPolynomials a

(<+) :: RatioOfPolynomials a -> BaseRing (RatioOfPolynomials a) -> RatioOfPolynomials a

evaluate :: RatioOfPolynomials a -> [BaseRing (RatioOfPolynomials a)] -> BaseRing (RatioOfPolynomials a)

evaluateAt :: [BaseRing (RatioOfPolynomials a)] -> RatioOfPolynomials a -> BaseRing (RatioOfPolynomials a)

substitute :: [Maybe (BaseRing (RatioOfPolynomials a))] -> RatioOfPolynomials a -> RatioOfPolynomials a

changeVariables :: RatioOfPolynomials a -> [VariablesType (RatioOfPolynomials a)] -> RatioOfPolynomials a

C a => C (A a)

Defined in Math.Algebra.Hspray

Methods

zero :: A a

(+) :: A a -> A a -> A a

(-) :: A a -> A a -> A a

negate :: A a -> A a

C a => C (A a)

Defined in Math.Algebra.Hspray

Methods

(/) :: A a -> A a -> A a

recip :: A a -> A a

fromRational' :: Rational -> A a

(^-) :: A a -> Integer -> A a

C a => C (A a)

Defined in Math.Algebra.Hspray

Methods

(*) :: A a -> A a -> A a

one :: A a

fromInteger :: Integer -> A a

(^) :: A a -> Integer -> A a

(Eq a, C a) => C (A a)

Defined in Math.Algebra.Hspray

Methods

isZero :: A a -> Bool

(Eq a, C a) => C (A a) (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: A a -> RatioOfPolynomials a -> RatioOfPolynomials a

(Eq a, C a) => C (Polynomial a) (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Polynomial a -> OneParameterSpray a -> OneParameterSpray a

(Eq a, C a) => C (Polynomial a) (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Polynomial a -> RatioOfPolynomials a -> RatioOfPolynomials a

(Eq a, C a) => C (A a) (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfPolynomials a -> A a -> RatioOfPolynomials a

(Eq a, C a) => C (Polynomial a) (OneParameterSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: OneParameterSpray a -> Polynomial a -> OneParameterSpray a

(Eq a, C a) => C (Polynomial a) (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfPolynomials a -> Polynomial a -> RatioOfPolynomials a

type BaseRing (Polynomial a)

Defined in Math.Algebra.Hspray

type BaseRing (Polynomial a) = a

type BaseRing (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

type BaseRing (RatioOfPolynomials a) = a

type VariablesType (Polynomial a)

Defined in Math.Algebra.Hspray

type VariablesType (Polynomial a) = Polynomial a

type VariablesType (RatioOfPolynomials a)

Defined in Math.Algebra.Hspray

type VariablesType (RatioOfPolynomials a) = Polynomial a

type Rational' = Rational

The type Rational' is used to introduce the univariate polynomials with rational coefficients (QPolynomial). It is similar to the well-known type Rational (actually these two types are the same but Rational' has more instances and we need them for the univariate polynomials).

type Polynomial a = T (A a)

The type Polynomial a is used to represent univariate polynomials.

type QPolynomial = Polynomial Rational'

type RatioOfPolynomials a = T (Polynomial a)

type RatioOfQPolynomials = RatioOfPolynomials Rational'

prettyRatioOfPolynomials

Arguments

:: (Eq a, C a, Show a)

=> String

string (usually a single letter) to denote the variable, e.g. "a"

-> RatioOfPolynomials a

-> String

Pretty form of a ratio of univariate polynomials

prettyRatioOfQPolynomials

Arguments

:: String

a string to denote the variable, e.g. "a"

-> RatioOfQPolynomials

-> String

Pretty form of a ratio of univariate polynomials with rational coefficients

constPoly :: a -> Polynomial a

Constant univariate polynomial

polyFromCoeffs :: [a] -> Polynomial a

Univariate polynomial from its coefficients (ordered by increasing degrees)

soleParameter :: C a => Polynomial a

The variable of a univariate polynomial; it is called "soleParameter" because this it represents the parameter of a OneParameterSpray spray

constQPoly :: Rational' -> QPolynomial

Constant rational univariate polynomial

>>> import Number.Ratio ( (%) )
>>> constQPoly (2 % 3)

constQPoly (2 % 3) == qpolyFromCoeffs [2 % 3]

qpolyFromCoeffs :: [Rational'] -> QPolynomial

Rational univariate polynomial from coefficients

>>> import Number.Ratio ( (%) )
>>> qpolyFromCoeffs [2 % 3, 5, 7 % 4]

qsoleParameter :: QPolynomial

The variable of a univariate rational polynomial; it is called "qsoleParameter" because it represents the parameter of a OneParameterQSpray spray

qsoleParameter == qpolyFromCoeffs [0, 1]

evalRatioOfPolynomials

Arguments

:: C a

=> a

the value at which the evaluation is desired

-> RatioOfPolynomials a

-> a

Evaluates a ratio of univariate polynomials

One-parameter sprays

The OneParameterSpray sprays represent multivariate polynomials with coefficients depending on a unique parameter. These sprays lost their interest in version 0.4.0.0 (see CHANGELOG or README). One can use the more general ParametricSpray sprays instead.

type OneParameterSpray a = Spray (RatioOfPolynomials a)

type OneParameterQSpray = OneParameterSpray Rational'

prettyOneParameterSprayX1X2X3

Arguments

:: (Eq a, Show a, C a)

=> String

string to denote the parameter of the spray, e.g. "a"

-> String

typically a letter, to denote the non-indexed variables

-> OneParameterSpray a

a one-parameter spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter spray, using a string (typically a letter) followed by an index to denote the variables

prettyOneParameterSprayXYZ

Arguments

:: (Eq a, Show a, C a)

=> String

string to denote the parameter of the spray, e.g. "a"

-> [String]

typically some letters, to denote the main variables

-> OneParameterSpray a

a one-parameter spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter spray, using some given strings (typically some letters) to denote the variables if possible, i.e. if enough letters are provided; otherwise this function behaves exactly like prettyOneParameterSprayX1X2X3 a where a is the first provided letter

prettyOneParameterSpray

Arguments

:: (Eq a, Show a, C a)

=> String

string to denote the parameter of the spray, e.g. "a"

-> OneParameterSpray a

a one-parameter spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter spray; see the definition below and see prettyOneParameterSprayXYZ

prettyOneParameterSpray a spray == prettyOneParameterSprayXYZ a ["x","y","z"] spray

prettyOneParameterSpray'

Arguments

:: (Eq a, Show a, C a)

=> String

string to denote the parameter of the spray, e.g. "a"

-> OneParameterSpray a

a one-parameter spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter spray; see the definition below and see prettyOneParameterSprayXYZ

prettyOneParameterSpray' a spray == prettyOneParameterSprayXYZ a ["X","Y","Z"] spray

prettyOneParameterQSprayX1X2X3

Arguments

:: String

usually a letter, to denote the parameter of the spray, e.g. "a"

-> String

usually a letter, to denote the non-indexed variables of the spray

-> OneParameterQSpray

a one-parameter rational spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter rational spray, using a string (typically a letter) followed by an index to denote the variables

prettyOneParameterQSprayXYZ

Arguments

:: String

usually a letter, to denote the parameter of the spray, e.g. "a"

-> [String]

usually some letters, to denote the variables of the spray

-> OneParameterQSpray

a one-parameter rational spray; note that this function does not simplify it

-> String

Pretty form of a one-parameter rational spray, using some given strings (typically some letters) to denote the variables if possible, i.e. if enough letters are provided; otherwise this function behaves exactly like prettyOneParameterQSprayX1X2X3 a where a is the first provided letter

prettyOneParameterQSpray

Arguments

:: String

usually a letter, to denote the parameter of the spray, e.g. "a"

-> OneParameterQSpray

the one-parameter rational spray to be printed; note that this function does not simplify it

-> String

Pretty form of a one-parameter rational spray, using "x", "y" and "z" for the variables if possible; i.e. if the spray does not have more than three variables, otherwise "x1", "x2", ... are used to denote the variables

prettyOneParameterQSpray a == prettyOneParameterQSprayXYZ a ["x","y","z"]

prettyOneParameterQSpray'

Arguments

:: String

usually a letter, to denote the parameter of the spray, e.g. "a"

-> OneParameterQSpray

the one-parameter rational spray to be printed; note that this function does not simplify it

-> String

Pretty form of a one-parameter rational spray, using "X", "Y" and "Z" for the variables if possible; i.e. if the spray does not have more than three variables, otherwise "X1", "X2", ... are used

prettyOneParameterQSpray' a == prettyOneParameterQSprayXYZ a ["X","Y","Z"]

evalOneParameterSpray :: (Eq a, C a) => OneParameterSpray a -> a -> Spray a

Substitutes a value to the parameter of a one-parameter spray (the variable occurring in its coefficients)

evalOneParameterSpray spray x == substituteParameters spray [x]

substituteTheParameter :: (Eq a, C a) => OneParameterSpray a -> a -> Spray a

Substitutes a value to the parameter of a one-parameter spray; same as evalOneParameterSpray

substituteTheParameter spray x == substituteParameters spray [x]

evalOneParameterSpray'

Arguments

:: (Eq a, C a)

=> OneParameterSpray a

one-parameter spray to be evaluated

-> a

a value for the parameter

-> [a]

some values for the variables

-> a

Substitutes a value to the parameter of a one-parameter spray as well as some values to the variables of this spray

evalOneParameterSpray' spray a xs == evalParametricSpray' spray [a] xs

evalOneParameterSpray'' :: (Eq a, C a) => OneParameterSpray a -> [a] -> RatioOfPolynomials a

Substitutes some values to the variables of a one-parameter spray; same as evalParametricSpray

Ratios of sprays

An object of type RatioOfSprays represents a fraction of two multivariate polynomials.

data RatioOfSprays a

A RatioOfSprays a object represents a fraction of two multivariate polynomials whose coefficients are of type a, which represents a field. These two polynomials are represented by two Spray a objects. Generally we do not use this constructor to build a ratio of sprays: we use the %//% operator instead, because it always returns an irreducible ratio of sprays, meaning that its corresponding fraction of polynomials is irreducible, i.e. its numerator and its denominator are coprime. You can use this constructor if you are sure that the numerator and the denominator are coprime. This can save some computation time, but unfortunate consequences can occur if the numerator and the denominator are not coprime. An arithmetic operation on ratios of sprays always returns an irreducible ratio of sprays under the condition that the ratios of sprays it involves are irreducible. Moreover, it never returns a ratio of sprays with a constant denominator other than the unit spray. If you use this constructor with a constant denominator, always set this denominator to the unit spray (by dividing the numerator by the constant value of the denominator).

Constructors

RatioOfSprays

Fields

• _numerator :: Spray a
• _denominator :: Spray a

Instances

(Eq a, C a) => C a (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> ParametricSpray a -> ParametricSpray a

(C a, Eq a) => C a (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: a -> RatioOfSprays a -> RatioOfSprays a

(Eq a, C a) => C a (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: ParametricSpray a -> a -> ParametricSpray a

(C a, Eq a) => C a (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfSprays a -> a -> RatioOfSprays a

Show a => Show (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

showsPrec :: Int -> RatioOfSprays a -> ShowS

show :: RatioOfSprays a -> String

showList :: [RatioOfSprays a] -> ShowS

(C a, Eq a) => Eq (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

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

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

(Eq a, C a) => FunctionLike (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Associated Types

type BaseRing (RatioOfSprays a)

type VariablesType (RatioOfSprays a)

Methods

numberOfVariables :: RatioOfSprays a -> Int

permuteVariables :: [Int] -> RatioOfSprays a -> RatioOfSprays a

swapVariables :: (Int, Int) -> RatioOfSprays a -> RatioOfSprays a

involvesVariable :: RatioOfSprays a -> Int -> Bool

dropVariables :: Int -> RatioOfSprays a -> RatioOfSprays a

derivative :: Int -> RatioOfSprays a -> RatioOfSprays a

(^+^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^-^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^*^) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(^**^) :: RatioOfSprays a -> Int -> RatioOfSprays a

(*^) :: BaseRing (RatioOfSprays a) -> RatioOfSprays a -> RatioOfSprays a

(+>) :: BaseRing (RatioOfSprays a) -> RatioOfSprays a -> RatioOfSprays a

(<+) :: RatioOfSprays a -> BaseRing (RatioOfSprays a) -> RatioOfSprays a

evaluate :: RatioOfSprays a -> [BaseRing (RatioOfSprays a)] -> BaseRing (RatioOfSprays a)

evaluateAt :: [BaseRing (RatioOfSprays a)] -> RatioOfSprays a -> BaseRing (RatioOfSprays a)

substitute :: [Maybe (BaseRing (RatioOfSprays a))] -> RatioOfSprays a -> RatioOfSprays a

changeVariables :: RatioOfSprays a -> [VariablesType (RatioOfSprays a)] -> RatioOfSprays a

(C a, Eq a) => C (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

zero :: RatioOfSprays a

(+) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

(-) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

negate :: RatioOfSprays a -> RatioOfSprays a

(C a, Eq a) => C (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(/) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

recip :: RatioOfSprays a -> RatioOfSprays a

fromRational' :: Rational -> RatioOfSprays a

(^-) :: RatioOfSprays a -> Integer -> RatioOfSprays a

(C a, Eq a) => C (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(*) :: RatioOfSprays a -> RatioOfSprays a -> RatioOfSprays a

one :: RatioOfSprays a

fromInteger :: Integer -> RatioOfSprays a

(^) :: RatioOfSprays a -> Integer -> RatioOfSprays a

(Eq a, C a) => C (Spray a) (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Spray a -> ParametricSpray a -> ParametricSpray a

(C a, Eq a) => C (Spray a) (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(*>) :: Spray a -> RatioOfSprays a -> RatioOfSprays a

(Eq a, C a) => C (Spray a) (ParametricSpray a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: ParametricSpray a -> Spray a -> ParametricSpray a

(C a, Eq a) => C (Spray a) (RatioOfSprays a)

Defined in Math.Algebra.Hspray

Methods

(<*) :: RatioOfSprays a -> Spray a -> RatioOfSprays a

type BaseRing (RatioOfSprays a)

Defined in Math.Algebra.Hspray

type BaseRing (RatioOfSprays a) = a

type VariablesType (RatioOfSprays a)

Defined in Math.Algebra.Hspray

type VariablesType (RatioOfSprays a) = Spray a

type RatioOfQSprays = RatioOfSprays Rational

(%:%) :: Spray a -> Spray a -> RatioOfSprays a infixl 7

Ratio of sprays from numerator and denominator, without reducing the fraction

(%//%) :: (Eq a, C a) => Spray a -> Spray a -> RatioOfSprays a infixl 7

Irreducible ratio of sprays from numerator and denominator; alias of (^/^)

(^/^) :: (Eq a, C a) => Spray a -> Spray a -> RatioOfSprays a infixl 7

Irreducible ratio of sprays from numerator and denominator; alias of (%//%)

(%/%) :: (Eq a, C a) => RatioOfSprays a -> Spray a -> RatioOfSprays a infixl 7

Division of a ratio of sprays by a spray; the result is an irreducible fraction

isConstantRatioOfSprays :: (Eq a, C a) => RatioOfSprays a -> Bool

Whether a ratio of sprays is constant; same as isConstant

isPolynomialRatioOfSprays :: (Eq a, C a) => RatioOfSprays a -> Bool

Whether a ratio of sprays actually is polynomial, that is, whether its denominator is a constant spray (and then it should be the unit spray)

>>> x = qlone 1
>>> y = qlone 2
>>> p = x^**^4 ^-^ y^**^4
>>> q = x ^-^ y
>>> isPolynomialRatioOfSprays $ p %//% q
True
>>> isPolynomialRatioOfSprays $ p %:% q
False

zeroRatioOfSprays :: (C a, Eq a) => RatioOfSprays a

The null ratio of sprays

zeroROS :: (C a, Eq a) => RatioOfSprays a

The null ratio of sprays

unitRatioOfSprays :: (C a, Eq a) => RatioOfSprays a

The unit ratio of sprays

unitROS :: (C a, Eq a) => RatioOfSprays a

The unit ratio of sprays

constantRatioOfSprays :: (Eq a, C a) => a -> RatioOfSprays a

Constant ratio of sprays

asRatioOfSprays :: C a => Spray a -> RatioOfSprays a

Coerces a spray to a ratio of sprays

evalRatioOfSprays :: (Eq a, C a) => RatioOfSprays a -> [a] -> a

Evaluates a ratio of sprays; same as evaluate

substituteRatioOfSprays :: (Eq a, C a) => [Maybe a] -> RatioOfSprays a -> RatioOfSprays a

Substitutes some values to some variables of a ratio of sprays; same as substitute

fromRatioOfPolynomials :: (Eq a, C a) => RatioOfPolynomials a -> RatioOfSprays a

Converts a ratio of polynomials to a ratio of sprays

fromRatioOfQPolynomials :: RatioOfQPolynomials -> RatioOfQSprays

Converts a ratio of rational polynomials to a ratio of rational sprays; this is not a specialization of fromRatioOfPolynomials because RatioOfQPolynomials is RatioOfPolynomials a with a = Rational', not with a = Rational

showRatioOfSprays

Arguments

:: (Eq a, C a)

=> ((Spray a, Spray a) -> (String, String))

function which prints a pair of sprays that will be applied to the numerator and the denominator

-> (String, String)

pair of braces to enclose the numerator and the denominator

-> String

represents the quotient bar

-> RatioOfSprays a

-> String

General function to print a RatioOfSprays object

showRatioOfNumSprays

Arguments

:: (Num a, Ord a, C a)

=> (a -> String)

function mapping a positive coefficient to a string

-> ([Exponents] -> [String])

prints the monomials

-> (String, String)

pair of braces to enclose the numerator and the denominator

-> String

represents the quotient bar

-> RatioOfSprays a

-> String

Prints a ratio of sprays with numeric coefficients

showRatioOfQSprays

Arguments

:: ([Exponents] -> [String])

prints the monomials

-> (String, String)

pair of braces to enclose the numerator and the denominator

-> String

represents the quotient bar

-> RatioOfQSprays

-> String

Prints a ratio of sprays with rational coefficients

showRatioOfSpraysXYZ

Arguments

:: forall a. (Eq a, C a)

=> [String]

typically some letters, to represent the variables

-> (a -> String)

function mapping a coefficient to a string, typically show

-> (String, String)

used to enclose the coefficients, usually a pair of braces

-> (String, String)

pair of braces to enclose the numerator and the denominator

-> String

represents the quotient bar

-> RatioOfSprays a

-> String

Prints a ratio of sprays

showRatioOfSpraysXYZ'

Arguments

:: (Eq a, C a)

=> [String]

typically some letters, to represent the variables

-> (a -> String)

function mapping a coefficient to a string, typically show

-> RatioOfSprays a

-> String

Prints a ratio of sprays

showRatioOfSpraysX1X2X3

Arguments

:: forall a. (Eq a, C a)

=> String

typically a letter, to represent the variables

-> (a -> String)

function mapping a coefficient to a string, typically show

-> (String, String)

used to enclose the coefficients, usually a pair of braces

-> (String, String)

pair of braces to enclose the numerator and the denominator

-> String

represents the quotient bar

-> RatioOfSprays a

-> String

Prints a ratio of sprays

showRatioOfSpraysX1X2X3'

Arguments

:: (Eq a, C a)

=> String

typically a letter, to represent the variables

-> (a -> String)

function mapping a coefficient to a string, typically show

-> RatioOfSprays a

-> String

Prints a ratio of sprays

prettyRatioOfQSpraysXYZ

Arguments

:: [String]

typically some letters, to represent the variables

-> RatioOfQSprays

-> String

Prints a ratio of sprays with rational coefficients

prettyRatioOfQSpraysX1X2X3

Arguments

:: String

typically a letter, to represent the non-indexed variables

-> RatioOfQSprays

-> String

Prints a ratio of sprays with rational coefficients, printing the monomials in the style of "x1^2.x2.x3^3"

prettyRatioOfQSprays :: RatioOfQSprays -> String

Prints a ratio of sprays with rational coefficients

prettyRatioOfQSprays rOS == prettyRatioOfQSpraysXYZ ["x","y","z"] rOS

prettyRatioOfQSprays' :: RatioOfQSprays -> String

Prints a ratio of sprays with rational coefficients

prettyRatioOfQSprays' rOS == prettyRatioOfQSpraysXYZ ["X","Y","Z"] rOS

prettyRatioOfNumSpraysXYZ

Arguments

:: (Num a, Ord a, C a, Show a)

=> [String]

typically some letters, to represent the variables

-> RatioOfSprays a

-> String

Prints a ratio of sprays with numeric coefficients

prettyRatioOfNumSpraysX1X2X3

Arguments

:: (Num a, Ord a, C a, Show a)

=> String

typically a letter, to represent the variables

-> RatioOfSprays a

-> String

Prints a ratio of sprays with numeric coefficients, printing the monomials in the style of "x1^2.x2.x3^3"

prettyRatioOfNumSprays :: (Num a, Ord a, C a, Show a) => RatioOfSprays a -> String

Prints a ratio of sprays with numeric coefficients

prettyRatioOfNumSprays rOS == prettyRatioOfNumSpraysXYZ ["x","y","z"] rOS

prettyRatioOfNumSprays' :: (Num a, Ord a, C a, Show a) => RatioOfSprays a -> String

Prints a ratio of sprays with numeric coefficients

prettyRatioOfNumSprays' rOS == prettyRatioOfNumSpraysXYZ ["X","Y","Z"] rOS

Parametric sprays

There are three types of parametric sprays: OneParameterSpray, SimpleParametricSpray and ParametricSpray. These are sprays of type Spray b where b has the class FunctionLike. When we say "parametric spray" in the documentation, we mean either such a spray or more precisely a ParametricSpray spray.

type SimpleParametricSpray a = Spray (Spray a)

type SimpleParametricQSpray = SimpleParametricSpray Rational

type ParametricSpray a = Spray (RatioOfSprays a)

type ParametricQSpray = ParametricSpray Rational

canCoerceToSimpleParametricSpray :: (Eq a, C a) => ParametricSpray a -> Bool

Whether the coefficients of a parametric spray polynomially depend on their parameters; I do not know why, but it seems to be the case for the Jacobi polynomials

>>> canCoerceToSimpleParametricSpray (jacobiPolynomial 8)
True

asSimpleParametricSprayUnsafe :: ParametricSpray a -> SimpleParametricSpray a

Coerces a parametric spray to a simple parametric spray, without checking this makes sense with canCoerceToSimpleParametricSpray

asSimpleParametricSpray :: (Eq a, C a) => ParametricSpray a -> SimpleParametricSpray a

Coerces a parametric spray to a simple parametric spray, after checking this makes sense with canCoerceToSimpleParametricSpray

fromOneParameterSpray :: (Eq a, C a) => OneParameterSpray a -> ParametricSpray a

Converts a `OneParameterSpray a` spray to a `ParametricSpray a`

fromOneParameterQSpray :: OneParameterQSpray -> ParametricQSpray

Converts a OneParameterQSpray spray to a ParametricQSpray

parametricSprayToOneParameterSpray :: forall a. (Eq a, C a) => ParametricSpray a -> OneParameterSpray a

Converts a parametric spray to a one-parameter spray, without checking the conversion makes sense

parametricQSprayToOneParameterQSpray :: ParametricQSpray -> OneParameterQSpray

Converts a rational parametric spray to a rational one-parameter spray, without checking the conversion makes sense

gegenbauerPolynomial :: Int -> SimpleParametricQSpray

Gegenbauer polynomials; we mainly provide them to give an example of the SimpleParametricSpray type

>>> gp = gegenbauerPolynomial 3
>>> putStrLn $ prettySimpleParametricQSpray gp
{ (4/3)*a^3 + 4*a^2 + (8/3)*a }*X^3 + { -2*a^2 - 2*a }*X
>>> putStrLn $ prettyQSpray'' $ substituteParameters gp [1]
8*X^3 - 4*X

jacobiPolynomial :: Int -> ParametricQSpray

Jacobi polynomial; the n-th Jacobi polynomial is a univariate polynomial of degree n with two parameters, except for the case n=0 where it has no parameter

>>> jP = jacobiPolynomial 1
>>> putStrLn $ prettyParametricQSprayABCXYZ ["alpha", "beta"] ["X"] jP
{ [ (1/2)*alpha + (1/2)*beta + 1 ] }*X + { [ (1/2)*alpha - (1/2)*beta ] }

numberOfParameters :: FunctionLike b => Spray b -> Int

Number of parameters in a parametric spray

>>> numberOfParameters (jacobiPolynomial 4)
2

changeParameters

Arguments

:: (FunctionLike b, Eq b, C b)

=> Spray b

OneParameterSpray a, SimpleParametricSpray a, or ParametricSpray a

-> [VariablesType b]

[Polynomial a] or [Spray a], the new variables

-> Spray b

Apply polynomial transformations to the parameters of a parametric spray; e.g. you have a two-parameters polynomial \(P_{a, b}(X, Y, Z)\) and you want to get \(P_{a^2, b^2}(X, Y, Z)\), or the one-parameter polynomial \(P_{a, a}(X, Y, Z)\)

>>> jp = jacobiPolynomial 4
>>> a = qlone 1
>>> b = qlone 2
>>> changeParameters jp [a^**^2, b^**^2]

substituteParameters

Arguments

:: (FunctionLike b, Eq (BaseRing b), C (BaseRing b))

=> Spray b

OneParameterSpray a, SimpleParametricSpray a, or ParametricSpray a

-> [BaseRing b]

values of type a to be substituted to the parameters

-> Spray (BaseRing b)

output: a Spray a spray

Substitutes some values to the parameters of a parametric spray

>>> jacobi3 = jacobiPolynomial 3
>>> legendre3 = substituteParameters jp [0, 0]

evalParametricSpray

Arguments

:: (Eq b, C (BaseRing b) b, C b)

=> Spray b

OneParameterSpray a, SimpleParametricSpray a, or ParametricSpray a

-> [BaseRing b]

values of type a to be substituted to the variables

-> b

Substitutes some values to the variables of a parametric spray

evalParametricSpray'

Arguments

:: (FunctionLike b, Eq (BaseRing b), C (BaseRing b) b)

=> Spray b

OneParameterSpray a, SimpleParametricSpray a, or ParametricSpray a

-> [BaseRing b]

values of type a to be substituted to the parameters

-> [BaseRing b]

values of type a to be substituted to the variables

-> BaseRing b

result: a value of type a

Substitutes some values to the parameters of a parametric spray as well as some values to its variables

prettyParametricQSprayABCXYZ

Arguments

:: [String]

usually some letters, to denote the parameters of the spray

-> [String]

usually some letters, to denote the variables of the spray

-> ParametricQSpray

a parametric rational spray

-> String

Pretty form of a parametric rational spray, using some given strings (typically some letters) to denote the parameters and some given strings (typically some letters) to denote the variables

>>> type PQS = ParametricQSpray
>>> :{
>>> f :: (QSpray, QSpray) -> (PQS, PQS, PQS) -> PQS
>>> f (a, b) (x, y, z) =
>>> (a %:% (a ^+^ b)) *^ x^**^2  ^+^  (b %:% (a ^+^ b)) *^ (y ^*^ z)
>>> :}
>>> a = qlone 1
>>> b = qlone 2
>>> x = lone 1 :: PQS
>>> y = lone 2 :: PQS
>>> z = lone 3 :: PQS
>>> pqs = f (a, b) (x, y, z)
>>> putStrLn $ prettyParametricQSprayABCXYZ ["a","b"] ["X","Y","Z"] pqs
{ [ a ] %//% [ a + b ] }*X^2 + { [ b ] %//% [ a + b ] }*Y.Z

prettyParametricQSpray :: ParametricQSpray -> String

Pretty form of a parametric rational spray

prettyParametricQSpray == prettyParametricQSprayABCXYZ ["a"] ["X","Y","Z"]

prettyParametricNumSprayABCXYZ

Arguments

:: (Num a, Ord a, Show a, C a)

=> [String]

usually some letters, to denote the parameters of the spray

-> [String]

usually some letters, to denote the variables of the spray

-> ParametricSpray a

a parametric numeric spray

-> String

Pretty form of a numeric parametric spray, using some given strings (typically some letters) to denote the parameters and some given strings (typically some letters) to denote the variables; rather use prettyParametricQSprayABCXYZ for a rational parametric spray

prettyParametricNumSpray

Arguments

:: (Num a, Ord a, Show a, C a)

=> ParametricSpray a

a parametric numeric spray

-> String

Pretty form of a numeric parametric spray; rather use prettyParametricQSpray for a rational parametric spray

prettyParametricNumSpray == prettyParametricNumSprayABCXYZ ["a"] ["X","Y","Z"]

prettySimpleParametricQSprayABCXYZ

Arguments

:: [String]

usually some letters, to denote the parameters of the spray

-> [String]

usually some letters, to denote the variables of the spray

-> SimpleParametricQSpray

a parametric rational spray

-> String

Pretty form of a simple parametric rational spray, using some given strings (typically some letters) to denote the parameters and some given strings (typically some letters) to denote the variables

>>> type SPQS = SimpleParametricQSpray
>>> :{
>>> f :: (QSpray, QSpray) -> (SPQS, SPQS, SPQS) -> SPQS
>>> f (a, b) (x, y, z) =
>>> (a ^+^ b) *^ x^**^2  ^+^  (a^**^2 ^+^ b^**^2) *^ (y ^*^ z)
>>> :}
>>> a = qlone 1
>>> b = qlone 2
>>> x = lone 1 :: SPQS
>>> y = lone 2 :: SPQS
>>> z = lone 3 :: SPQS
>>> spqs = f (a, b) (x, y, z)
>>> putStrLn $ prettySimpleParametricQSprayABCXYZ ["a","b"] ["X","Y","Z"] spqs
{ a + b }*X^2 + { a^2 + b^2 }*Y.Z

prettySimpleParametricQSpray :: SimpleParametricQSpray -> String

Pretty form of a simple parametric rational spray

prettySimpleParametricQSpray == prettySimpleParametricQSprayABCXYZ ["a"] ["X","Y","Z"]

prettySimpleParametricNumSprayABCXYZ

Arguments

:: (Num a, Ord a, Show a, C a)

=> [String]

usually some letters, to denote the parameters of the spray

-> [String]

usually some letters, to denote the variables of the spray

-> SimpleParametricSpray a

a numeric simple parametric spray

-> String

Pretty form of a numeric simple parametric spray, using some given strings (typically some letters) to denote the parameters and some given strings (typically some letters) to denote the variables; rather use prettySimpleParametricQSprayABCXYZ for a rational simple parametric spray

prettySimpleParametricNumSpray

Arguments

:: (Num a, Ord a, Show a, C a)

=> SimpleParametricSpray a

a numeric simple parametric spray

-> String

Pretty form of a numeric simple parametric spray; rather use prettySimpleParametricQSpray for a numeric simple parametric spray

prettySimpleParametricNumSpray == prettySimpleParametricNumSprayABCXYZ ["a"] ["X","Y","Z"]

Queries on a spray

getCoefficient

Arguments

:: C a

=> [Int]

sequence of exponents; trailing zeros are dropped

-> Spray a

spray

-> a

coefficient of the monomial given by the sequence of exponents

Get coefficient of a term of a spray

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = 2 *^ (2 *^ (x^**^3 ^*^ y^**^2)) ^+^ 4*^z ^+^ 5*^unitSpray
>>> getCoefficient [3, 2] p -- coefficient of x^3.y^2
4
>>> getCoefficient [3, 2, 0] p -- same as getCoefficient [3, 2] p
4
>>> getCoefficient [0, 4] p -- coefficient of y^4
0

getConstantTerm :: C a => Spray a -> a

Get the constant term of a spray

getConstantTerm p == getCoefficient [] p

isZeroSpray :: Spray a -> Bool

Whether a spray is the zero spray

isConstantSpray :: (Eq a, C a) => Spray a -> Bool

Whether a spray is constant; same as isConstant

isHomogeneousSpray :: (Eq a, C a) => Spray a -> (Bool, Maybe Int)

Checks whether the multivariate polynomial defined by a spray is homogeneous and also returns the degree in case this is true

allExponents :: Spray a -> [Exponents]

Get all the exponents of a spray

allCoefficients :: Spray a -> [a]

Get all the coefficients of a spray

Evaluation of a spray

evalSpray :: (Eq a, C a) => Spray a -> [a] -> a

Evaluates a spray; same as evaluate

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> spray = 2*^x^**^2 ^-^ 3*^y
>>> evalSpray spray [2, 1]
5

substituteSpray :: (Eq a, C a) => [Maybe a] -> Spray a -> Spray a

Substitutes some values to some variables of a spray; same as substitute

>>> x1 = lone 1 :: Spray Int
>>> x2 = lone 2 :: Spray Int
>>> x3 = lone 3 :: Spray Int
>>> p = x1^**^2 ^-^ x2 ^+^ x3 ^-^ unitSpray
>>> p' = substituteSpray [Just 2, Nothing, Just 3] p
>>> putStrLn $ prettyNumSprayX1X2X3 "x" p'
-x2 + 6 

composeSpray :: forall a. (C a, Eq a) => Spray a -> [Spray a] -> Spray a

Sustitutes the variables of a spray with some sprays; same as changeVariables

>>> x = lone 1 :: Spray Int
>>> y = lone 2 :: Spray Int
>>> z = lone 3 :: Spray Int
>>> p = x ^+^ y
>>> q = composeSpray p [x ^+^ y ^+^ z, z]
>>> putStrLn $ prettyNumSpray' q
X + Y + 2*Z

evalSpraySpray :: (Eq a, C a) => Spray (Spray a) -> [a] -> Spray a

Evaluates the coefficients of a spray with spray coefficients; same as substituteParameters

Division of sprays

sprayDivision

Arguments

:: (Eq a, C a)

=> Spray a

dividand

-> Spray a

divisor

-> (Spray a, Spray a)

(quotient, remainder)

Division of a spray by a spray

sprayDivisionRemainder :: forall a. (Eq a, C a) => Spray a -> [Spray a] -> Spray a

Remainder of the division of a spray by a list of divisors, using the lexicographic ordering of the monomials

pseudoDivision

Arguments

:: (Eq a, C a)

=> Spray a

A

-> Spray a

B

-> (Spray a, (Spray a, Spray a))

(C, (Q, R)) such that C^*^A = B^*^Q ^+^ R

Pseudo-division of two sprays A and B such that deg(A) >= deg(B) where deg is the degree with respect to the outermost variable.

Gröbner basis

groebnerBasis

Arguments

:: forall a. (Eq a, C a)

=> [Spray a]

list of sprays

-> Bool

whether to return the reduced basis

-> [Spray a]

Gröbner basis, always minimal and possibly reduced

groebnerBasis sprays True == reduceGroebnerBasis (groebnerBasis sprays False)

reduceGroebnerBasis :: forall a. (Eq a, C a) => [Spray a] -> [Spray a]

Reduces a Gröbner basis

Symmetric polynomials

esPolynomial

Arguments

:: (C a, Eq a)

=> Int

number of variables

-> Int

index

-> Spray a

Elementary symmetric polynomial

>>> putStrLn $ prettySpray' (esPolynomial 3 2)
(1)*x1.x2 + (1)*x1.x3 + (1)*x2.x3

psPolynomial

Arguments

:: forall a. (C a, Eq a)

=> Int

number of variables

-> Int

power

-> Spray a

Power sum polynomial

isSymmetricSpray :: forall a. (C a, Eq a) => Spray a -> Bool

Whether a spray is a symmetric polynomial, an inefficient algorithm (use the function with the same name in the jackpolynomials package if you need efficiency)

Resultant, subresultants, and Sturm-Habicht sequence

resultant

Arguments

:: (Eq a, C a)

=> Int

indicator of the variable with respect to which the resultant is desired (e.g. 1 for x)

-> Spray a

-> Spray a

-> Spray a

Resultant of two sprays

resultant'

Arguments

:: forall a. (Eq a, C a)

=> Int

indicator of the variable with respect to which the resultant is desired (e.g. 1 for x)

-> Spray a

-> Spray a

-> Spray a

Resultant of two sprays with coefficients in a field; this function is more efficient than the function resultant

resultant1 :: (Eq a, C a) => Spray a -> Spray a -> a

Resultant of two univariate sprays

subresultants

Arguments

:: (Eq a, C a)

=> Int

indicator of the variable with respect to which the subresultants are desired (e.g. 1 for x)

-> Spray a

-> Spray a

-> [Spray a]

Subresultants of two sprays (the principal subresultants, while the polynomialSubresultants function returns the polynomial subresultants). This function makes several calls to detLaplace and then it can be slow.

subresultants1 :: (Eq a, C a) => Spray a -> Spray a -> [a]

Subresultants of two univariate sprays. This function makes several calls to detLaplace and then it can be slow.

polynomialSubresultants

Arguments

:: (Eq a, C a)

=> Int

index of the variable with respect to which the subresultants will be computed (e.g. 2 for y)

-> Spray a

-> Spray a

-> [Spray a]

Polynomial subresultants of two sprays (the subresultants function computes the principal subresultants). This function makes several calls to detLaplace and then it can be slow.

sturmHabichtSequence

Arguments

:: (Eq a, C a)

=> Int

index of the variable with respect to which the Sturm-Habicht sequence will be computed (e.g. 2 for y)

-> Spray a

-> [Spray a]

Sturm-Habicht sequence of a spray. This function calls polynomialSubresultants and then it can be slow.

principalSturmHabichtSequence

Arguments

:: (Eq a, C a)

=> Int

index of the variable with respect to which the Sturm-Habicht sequence will be computed (e.g. 2 for y)

-> Spray a

-> [Spray a]

Principal Sturm-Habicht sequence of a spray. This function calls sturmHabicht sequence and then it can be slow.

Number of real roots of a univariate spray. These functions can be very

numberOfRealRoots :: (Eq a, C a, Num a) => Spray a -> Int

Number of real roots of a spray (that makes sense only for a spray on a ring embeddable in the real numbers). The roots are not counted with their multiplicity.

numberOfRealRoots' :: (Eq a, C a) => Spray a -> Int

Number of real roots of a spray (that makes sense only for a spray on a ring embeddable in the real numbers). The roots are not counted with their multiplicity.

numberOfRealRootsInOpenInterval

Arguments

:: (Num a, C a, Ord a)

=> Spray a

a spray

-> Maybe a

lower bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Maybe a

upper bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Int

Number of real roots of a spray in an open interval (that makes sense only for a spray on a ring embeddable in the real numbers).

numberOfRealRootsInOpenInterval'

Arguments

:: (C a, Ord a)

=> Spray a

a spray

-> Maybe a

lower bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Maybe a

upper bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Int

Number of real roots of a spray in an open interval (that makes sense only for a spray on a ring embeddable in the real numbers).

numberOfRealRootsInClosedInterval

Arguments

:: (Num a, C a, Ord a)

=> Spray a

a spray

-> Maybe a

lower bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Maybe a

upper bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Int

Number of real roots of a spray in a closed interval (that makes sense only for a spray on a ring embeddable in the real numbers). The roots are not counted with their multiplicity.

numberOfRealRootsInClosedInterval'

Arguments

:: (C a, Ord a)

=> Spray a

a spray

-> Maybe a

lower bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Maybe a

upper bound of the interval; use Just for a finite bound, and Nothing for minus infinity

-> Int

Number of real roots of a spray in a closed interval (that makes sense only for a spray on a ring embeddable in the real numbers). The roots are not counted with their multiplicity.

Greatest common divisor

gcdSpray :: forall a. (Eq a, C a) => Spray a -> Spray a -> Spray a

Greatest common divisor of two sprays with coefficients in a field

Matrices

detLaplace :: forall a. (Eq a, C a) => Matrix a -> a

Determinant of a matrix with entries in a ring by using Laplace expansion (this is slow); the numeric-prelude package provides some stuff to deal with matrices over a ring but it does not provide the determinant

detLaplace' :: forall a. (Eq a, C a) => T a -> a

Determinant of a matrix over a ring by using Laplace expansion; this is the same as detLaplace but for a matrix from the numeric-prelude package

characteristicPolynomial :: (Eq a, C a) => Matrix a -> Spray a

Characteristic polynomial of a square matrix

>>> import Data.Matrix (Matrix, fromLists)
>>> m = fromLists [ [12, 16, 4]
>>> , [16, 2, 8]
>>> , [8, 18, 10] ] :: Matrix Int
>>> spray = characteristicPolynomial m
>>> putStrLn $ prettyNumSpray spray
-x^3 + 24*x^2 + 268*x - 1936

Miscellaneous

sumOfSprays :: (Eq a, C a) => [Spray a] -> Spray a

Sum of sprays

productOfSprays :: (Eq a, C a) => [Spray a] -> Spray a

Product of sprays

(.^) :: (C a, Eq a) => Int -> a -> a infixr 7

Scale by an integer (I do not find this operation in numeric-prelude)

3 .^ x == x Algebra.Additive.+ x Algebra.Additive.+ x

(/>) :: (C k, C k a) => a -> k -> a infixr 7

Divides by a scalar in a module over a field

(/^) :: (C a, Eq a) => Spray a -> a -> Spray a infixr 7

Divides a spray by a scalar; you can equivalently use (/>) if the type of the scalar is not ambiguous

fromList

Arguments

:: (C a, Eq a)

=> [([Int], a)]

list of (exponents, coefficient)

-> Spray a

Creates a spray from a list of terms

toList :: Spray a -> [([Int], a)]

Spray as a list

fromRationalSpray :: Spray Rational -> Spray Double

Converts a spray with rational coefficients to a spray with double coefficients (useful for evaluation)

isPolynomialOf :: forall a. (C a, Eq a) => Spray a -> [Spray a] -> (Bool, Maybe (Spray a))

Whether a spray can be written as a polynomial of a given list of sprays; this polynomial is returned if this is true

>>> x = lone 1 :: Spray Rational
>>> y = lone 2 :: Spray Rational
>>> p1 = x ^+^ y
>>> p2 = x ^-^ y
>>> p = p1 ^*^ p2

isPolynomialOf p [p1, p2] == (True, Just $ x ^*^ y)

bombieriSpray :: (Eq a, C a) => Spray a -> Spray a

Bombieri spray (for internal usage in the 'scubature' package)

collinearSprays :: (Eq a, C a) => Spray a -> Spray a -> Bool

Whether two sprays are equal up to a scalar factor