



Synopsis 

(+) :: 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 :: C a => a > a > a   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 :: C a => a > a   log :: C a => a > a   logBase :: C a => a > a > a   (**) :: C a => a > a > a   sin :: C a => a > a   cos :: C a => a > a   tan :: C a => a > a   asin :: C a => a > a   acos :: C a => a > a   atan :: C a => a > a   sinh :: C a => a > a   cosh :: C a => a > a   tanh :: C a => a > a   asinh :: C a => a > a   acosh :: C a => a > a   atanh :: C a => a > a   abs :: C a => a > a   signum :: C a => a > a   quot :: C a => a > a > a   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 :: (C a, C b) => a > b   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   reduceRepeated :: (a > a > a) > a > a > Integer > a   isUnit :: C a => a > Bool   stdAssociate :: C a => a > a   stdUnit :: C a => a > a   stdUnitInv :: 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 b => a > b > b 


Documentation 


add and subtract elements





inverse with respect to +



zero element of the vector space


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.



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











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 Integers doesn't matter.
The previous solution used a Algebra.ToInteger.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 Algebra.Core.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/haskellcafe/2006September/018022.html












divMod :: C a => a > a > (a, a)  Source 
















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

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



Needed to work around shortcomings in GHC.












logBase :: C a => a > a > a  Source 




































quotRem :: C a => a > a > (a, a)  Source 


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













TODO: Should be moved to a continued fraction module.





Lossless conversion from any representation of a rational to Rational




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






stdAssociate :: 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.



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



Least common multiple


euclid :: (C a, C a) => (a > a > a) > a > a > a  Source 


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











Arbitraryprecision integers.
 Instances  



A fixedprecision integer type with at least the range [2^29 .. 2^291].
The exact range for a given implementation can be determined by using
Prelude.minBound and Prelude.maxBound from the Prelude.Bounded class.
 Instances  



Singleprecision floating point numbers.
It is desirable that this type be at least equal in range and precision
to the IEEE singleprecision type.
 Instances  



Doubleprecision floating point numbers.
It is desirable that this type be at least equal in range and precision
to the IEEE doubleprecision type.
 Instances  



scale a vector by a scalar


Produced by Haddock version 2.6.0 