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

Language | Haskell98 |

- (+), (-) :: C a => a -> a -> a
- (+), (-) :: C a => a -> a -> a
- negate :: C a => a -> a
- zero :: C a => a
- subtract :: C a => a -> a -> a
- sum :: C a => [a] -> a
- sum1 :: C a => [a] -> a
- isZero :: C a => a -> Bool
- (*) :: C a => a -> a -> a
- one :: C a => a
- fromInteger :: C a => Integer -> a
- (^) :: C a => a -> Integer -> a
- ringPower :: (C a, C b) => b -> a -> a
- sqr :: C a => a -> a
- product :: C a => [a] -> a
- product1 :: C a => [a] -> a
- div, mod :: C a => a -> a -> a
- div, mod :: C a => a -> a -> a
- divMod :: C a => a -> a -> (a, a)
- divides :: (C a, C a) => a -> a -> Bool
- even :: (C a, C a) => a -> Bool
- odd :: (C a, C a) => a -> Bool
- (/) :: C a => a -> a -> a
- recip :: C a => a -> a
- fromRational' :: C a => Rational -> a
- (^-) :: C a => a -> Integer -> a
- fieldPower :: (C a, C b) => b -> a -> a
- fromRational :: C a => Rational -> a
- (^/) :: C a => a -> Rational -> a
- sqrt :: C a => a -> a
- pi :: C a => a
- exp, log :: C a => a -> a
- exp, log :: C a => a -> a
- logBase, (**) :: C a => a -> a -> a
- logBase, (**) :: C a => a -> a -> a
- (^?) :: C a => a -> a -> a
- sin, tan, cos :: C a => a -> a
- sin, tan, cos :: C a => a -> a
- sin, tan, cos :: C a => a -> a
- asin, atan, acos :: C a => a -> a
- asin, atan, acos :: C a => a -> a
- asin, atan, acos :: C a => a -> a
- sinh, tanh, cosh :: C a => a -> a
- sinh, tanh, cosh :: C a => a -> a
- sinh, tanh, cosh :: C a => a -> a
- asinh, atanh, acosh :: C a => a -> a
- asinh, atanh, acosh :: C a => a -> a
- asinh, atanh, acosh :: C a => a -> a
- abs :: C a => a -> a
- signum :: C a => a -> a
- quot, rem :: C a => a -> a -> a
- quot, rem :: C a => a -> a -> a
- quotRem :: C a => a -> a -> (a, a)
- splitFraction :: (C a, C b) => a -> (b, a)
- fraction :: C a => a -> a
- truncate :: (C a, C b) => a -> b
- round :: (C a, C b) => a -> b
- ceiling, floor :: (C a, C b) => a -> b
- ceiling, floor :: (C a, C b) => a -> b
- approxRational :: (C a, C a) => a -> a -> Rational
- atan2 :: C a => a -> a -> a
- toRational :: C a => a -> Rational
- toInteger :: C a => a -> Integer
- fromIntegral :: (C a, C b) => a -> b
- isUnit :: C a => a -> Bool
- stdAssociate, stdUnitInv, stdUnit :: C a => a -> a
- stdAssociate, stdUnitInv, stdUnit :: C a => a -> a
- stdAssociate, stdUnitInv, stdUnit :: C a => a -> a
- extendedGCD :: C a => a -> a -> (a, (a, a))
- gcd :: C a => a -> a -> a
- lcm :: C a => a -> a -> a
- euclid :: (C a, C a) => (a -> a -> a) -> a -> a -> a
- extendedEuclid :: (C a, C a) => (a -> a -> (a, a)) -> a -> a -> (a, (a, a))
- type Rational = T Integer
- (%) :: C a => a -> a -> T a
- numerator :: T a -> a
- denominator :: T a -> a
- data Integer :: *
- data Int :: *
- data Float :: *
- data Double :: *
- (*>) :: C a v => a -> v -> v

# Documentation

subtract :: C a => a -> a -> a Source

`subtract`

is `(-)`

with swapped operand order.
This is the operand order which will be needed in most cases
of partial application.

Sum up all elements of a list. An empty list yields zero.

This function is inappropriate for number types like Peano.
Maybe we should make `sum`

a method of Additive.
This would also make `lengthLeft`

and `lengthRight`

superfluous.

sum1 :: C a => [a] -> a Source

Sum up all elements of a non-empty list. This avoids including a zero which is useful for types where no universal zero is available.

fromInteger :: C a => Integer -> a Source

(^) :: C a => a -> Integer -> a Source

The exponent has fixed type `Integer`

in order
to avoid an arbitrarily limitted range of exponents,
but to reduce the need for the compiler to guess the type (default type).
In practice the exponent is most oftenly fixed, and is most oftenly `2`

.
Fixed exponents can be optimized away and
thus the expensive computation of `Integer`

s doesn't matter.
The previous solution used a `C`

constrained type
and the exponent was converted to Integer before computation.
So the current solution is not less efficient.

A variant of `^`

with more flexibility is provided by `ringPower`

.

ringPower :: (C a, C b) => b -> a -> a Source

A prefix function of '(Algebra.Ring.^)' with a parameter order that fits the needs of partial application and function composition. It has generalised exponent.

See: Argument order of `expNat`

on
http://www.haskell.org/pipermail/haskell-cafe/2006-September/018022.html

fromRational' :: C a => Rational -> a Source

fieldPower :: (C a, C b) => b -> a -> a Source

A prefix function of '(Algebra.Field.^-)'. It has a generalised exponent.

fromRational :: C a => Rational -> a Source

Needed to work around shortcomings in GHC.

splitFraction :: (C a, C b) => a -> (b, a) Source

approxRational :: (C a, C a) => a -> a -> Rational Source

TODO: Should be moved to a continued fraction module.

toRational :: C a => a -> Rational Source

Lossless conversion from any representation of a rational to `Rational`

fromIntegral :: (C a, C b) => a -> b Source

stdAssociate, stdUnitInv, stdUnit :: C a => a -> a Source

stdAssociate, stdUnitInv, stdUnit :: C a => a -> a Source

stdAssociate, stdUnitInv, stdUnit :: C a => a -> a Source

extendedGCD :: C a => a -> a -> (a, (a, a)) Source

Compute the greatest common divisor and solve a respective Diophantine equation.

(g,(a,b)) = extendedGCD x y ==> g==a*x+b*y && g == gcd x y

TODO: This method is not appropriate for the PID class, because there are rings like the one of the multivariate polynomials, where for all x and y greatest common divisors of x and y exist, but they cannot be represented as a linear combination of x and y. TODO: The definition of extendedGCD does not return the canonical associate.

gcd :: C a => a -> a -> a Source

The Greatest Common Divisor is defined by:

gcd x y == gcd y x divides z x && divides z y ==> divides z (gcd x y) (specification) divides (gcd x y) x

extendedEuclid :: (C a, C a) => (a -> a -> (a, a)) -> a -> a -> (a, (a, a)) Source

denominator :: T a -> a Source

data Integer :: *

Arbitrary-precision integers.

data Int :: *

A fixed-precision integer type with at least the range `[-2^29 .. 2^29-1]`

.
The exact range for a given implementation can be determined by using
`minBound`

and `maxBound`

from the `Bounded`

class.

Bounded Int | |

Enum Int | |

Eq Int | |

Integral Int | |

Num Int | |

Ord Int | |

Read Int | |

Real Int | |

Show Int | |

Ix Int | |

Generic Int | |

Arbitrary Int | |

CoArbitrary Int | |

Storable Int | |

NFData Int | |

Random Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int | |

C Int Int | |

C Int Int | |

C Int Int | |

Sqr Int Int | |

C Int Int | |

C Int Int | |

type Rep Int = D1 D_Int (C1 C_Int (S1 NoSelector (Rec0 Int))) |

data Float :: *

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Enum Float | |

Eq Float | |

Floating Float | |

Fractional Float | |

Num Float | |

Ord Float | |

Read Float | |

Real Float | |

RealFloat Float | |

RealFrac Float | |

Show Float | |

Generic Float | |

Arbitrary Float | |

CoArbitrary Float | |

Storable Float | |

NFData Float | |

Random Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

C Float | |

Power Float | |

C Float Float | |

C Float Float | |

C Float Float | |

C Float Float | |

Sqr Float Float | |

C Float Float | |

C Float Float | |

C Float Float | |

type Rep Float = D1 D_Float (C1 C_Float (S1 NoSelector (Rec0 Float))) |

data Double :: *

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Enum Double | |

Eq Double | |

Floating Double | |

Fractional Double | |

Num Double | |

Ord Double | |

Read Double | |

Real Double | |

RealFloat Double | |

RealFrac Double | |

Show Double | |

Generic Double | |

Arbitrary Double | |

CoArbitrary Double | |

Storable Double | |

NFData Double | |

Random Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

C Double | |

Power Double | |

C Double Double | |

C Double Double | |

C Double Double | |

C Double Double | |

Sqr Double Double | |

C Double Double | |

C Double Double | |

C Double Double | |

type Rep Double = D1 D_Double (C1 C_Double (S1 NoSelector (Rec0 Double))) |