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




class 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)

If the type is ZeroTestable, then it should hold

  isZero a  ===  signum a == signum (negate a)

We do not require Ord as superclass since we also want to have Number.Complex as instance. We also do not require ZeroTestable as superclass, because we like to have expressions of foreign languages to be instances (cf. embedded domain specific language approach, EDSL), as well as function types.

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 a) => C (T a) 
Num a => C (T 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