MathObj.LaurentPolynomial
 Portability requires multi-parameter type classes Stability provisional Maintainer numericprelude@henning-thielemann.de
 Contents Basic Operations Show Additive Module Ring Field.C Comparisons Transformations of arguments
Description
Polynomials with negative and positive exponents.
Synopsis
data T a = Cons {
 expon :: Int coeffs :: [a]
}
const :: a -> T a
(!) :: C a => T a -> Int -> a
fromCoeffs :: [a] -> T a
fromShiftCoeffs :: Int -> [a] -> T a
fromPolynomial :: T a -> T a
fromPowerSeries :: T a -> T a
bounds :: T a -> (Int, Int)
translate :: Int -> T a -> T a
appPrec :: Int
add :: C a => T a -> T a -> T a
series :: C a => [T a] -> T a
addShiftedMany :: C a => [Int] -> [[a]] -> [a]
addShifted :: C a => Int -> [a] -> [a] -> [a]
negate :: C a => T a -> T a
sub :: C a => T a -> T a -> T a
scale :: C a => a -> [a] -> [a]
mul :: C a => T a -> T a -> T a
div :: (C a, C a) => T a -> T a -> T a
divExample :: T Rational
equivalent :: (Eq a, C a) => T a -> T a -> Bool
identical :: Eq a => T a -> T a -> Bool
isAbsolute :: C a => T a -> Bool
alternate :: C a => T a -> T a
reverse :: T a -> T a
adjoint :: C a => T (T a) -> T (T a)
Documentation
 data T a Source
Polynomial including negative exponents
Constructors
Cons
 expon :: Int coeffs :: [a] Instances
 Functor T C T C a b => C a (T b) (C a, C a b) => C a (T b) (Eq a, C a) => Eq (T a) Show a => Show (T a) C a => C (T a) C a => C (T a) (C a, C a) => C (T a)
Basic Operations
 const :: a -> T a Source
 (!) :: C a => T a -> Int -> a Source
 fromCoeffs :: [a] -> T a Source
 fromShiftCoeffs :: Int -> [a] -> T a Source
 fromPolynomial :: T a -> T a Source
 fromPowerSeries :: T a -> T a Source
 bounds :: T a -> (Int, Int) Source
 translate :: Int -> T a -> T a Source
Show
 appPrec :: Int Source
 add :: C a => T a -> T a -> T a Source
 series :: C a => [T a] -> T a Source
 addShiftedMany :: C a => [Int] -> [[a]] -> [a] Source

Add lists of numbers respecting a relative shift between the starts of the lists. The shifts must be non-negative. The list of relative shifts is one element shorter than the list of summands. Infinitely many summands are permitted, provided that runs of zero shifts are all finite.

We could add the lists either with foldl or with foldr, foldl would be straightforward, but more time consuming (quadratic time) whereas foldr is not so obvious but needs only linear time.

(stars denote the coefficients, frames denote what is contained in the interim results) foldl sums this way:

``` | | | *******************************
| | +--------------------------------
| |          ************************
| +----------------------------------
|                        ************
+------------------------------------
```

I.e. foldl would use much time find the time differences by successive subtraction 1.

foldr mixes this way:

```     +--------------------------------
| *******************************
|      +-------------------------
|      | ************************
|      |           +-------------
|      |           | ************
```
 addShifted :: C a => Int -> [a] -> [a] -> [a] Source
 negate :: C a => T a -> T a Source
 sub :: C a => T a -> T a -> T a Source
Module
 scale :: C a => a -> [a] -> [a] Source
Ring
 mul :: C a => T a -> T a -> T a Source
Field.C
 div :: (C a, C a) => T a -> T a -> T a Source
 divExample :: T Rational Source
Comparisons
 equivalent :: (Eq a, C a) => T a -> T a -> Bool Source
Two polynomials may be stored differently. This function checks whether two values of type LaurentPolynomial actually represent the same polynomial.
 identical :: Eq a => T a -> T a -> Bool Source
 isAbsolute :: C a => T a -> Bool Source
Check whether a Laurent polynomial has only the absolute term, that is, it represents the constant polynomial.
Transformations of arguments
 alternate :: C a => T a -> T a Source
p(z) -> p(-z)
 reverse :: T a -> T a Source
p(z) -> p(1/z)
 adjoint :: C a => T (T a) -> T (T a) Source

p(exp(ix)) -> conjugate(p(exp(ix)))

If you interpret (p*) as a linear operator on the space of Laurent polynomials, then (adjoint p *) is the adjoint operator.