Safe Haskell | None |
---|
- (+), (-) :: 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 -> aSource
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.
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 -> aSource
(^) :: C a => a -> Integer -> aSource
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 -> aSource
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 -> aSource
fieldPower :: (C a, C b) => b -> a -> aSource
A prefix function of '(Algebra.Field.^-)'. It has a generalised exponent.
fromRational :: C a => Rational -> aSource
Needed to work around shortcomings in GHC.
splitFraction :: (C a, C b) => a -> (b, a)Source
approxRational :: (C a, C a) => a -> a -> RationalSource
TODO: Should be moved to a continued fraction module.
toRational :: C a => a -> RationalSource
Lossless conversion from any representation of a rational to Rational
fromIntegral :: (C a, C b) => a -> bSource
stdAssociate, stdUnitInv, stdUnit :: C a => a -> aSource
stdAssociate, stdUnitInv, stdUnit :: C a => a -> aSource
stdAssociate, stdUnitInv, stdUnit :: C a => a -> aSource
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 -> aSource
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 -> aSource
data Integer
Arbitrary-precision integers.
data 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.
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.