numeric-prelude- An experimental alternative hierarchy of numeric type classes




class (C a, C a) => C a whereSource

This is the type class of a ring with a notion of an absolute value, satisfying the laws

                        a * b === b * a
   a /= 0  =>  abs (signum a) === 1
             abs a * signum a === a

Minimal definition: abs, signum.

If the type is in the Ord class we expect abs = absOrd and signum = signumOrd and we expect the following laws to hold:

      a + (max b c) === max (a+b) (a+c)
   negate (max b c) === min (negate b) (negate c)
      a * (max b c) === max (a*b) (a*c) where a >= 0
           absOrd a === max a (-a)

We do not require Ord as superclass since we also want to have Number.Complex as instance. abs for complex numbers alone may have an inappropriate type, because it does not reflect that the absolute value is a real number. You might prefer Number.Complex.magnitude. This type class is intended for unifying algorithms that work for both real and complex numbers. Note the similarity to Algebra.Units: abs plays the role of stdAssociate and signum plays the role of stdUnit.

Actually, since abs can be defined using max and negate we could relax the superclasses to Additive and Ord if his class would only contain signum.


abs :: a -> aSource

signum :: a -> aSource


C Double 
C Float 
C Int 
C Int8 
C Int16 
C Int32 
C Int64 
C Integer 
C Word 
C Word8 
C Word16 
C Word32 
C Word64 
C T 
C T 
C T 
(C a, Ord a, C a) => C (T a) 
(C a, C a) => C (T a) 
(C a, C a) => C (T a) 
(C a, C a, C a) => C (T a) 
C v => C (T a v) 
(Ord i, C a) => C (T i a) 
C v => C (T a v) 

absOrd :: (C a, Ord a) => a -> aSource

signumOrd :: (C a, Ord a) => a -> aSource