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

Safe HaskellSafe
LanguageHaskell98

Algebra.Absolute

Synopsis

Documentation

class C a => C a where Source #

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

Minimal complete definition

abs, signum

Methods

abs :: a -> a Source #

signum :: a -> a Source #

Instances

C Double Source # 
C Float Source # 
C Int Source # 

Methods

abs :: Int -> Int Source #

signum :: Int -> Int Source #

C Int8 Source # 

Methods

abs :: Int8 -> Int8 Source #

signum :: Int8 -> Int8 Source #

C Int16 Source # 
C Int32 Source # 
C Int64 Source # 
C Integer Source # 
C Word Source # 

Methods

abs :: Word -> Word Source #

signum :: Word -> Word Source #

C Word8 Source # 
C Word16 Source # 
C Word32 Source # 
C Word64 Source # 
C T Source # 

Methods

abs :: T -> T Source #

signum :: T -> T Source #

C T Source # 

Methods

abs :: T -> T Source #

signum :: T -> T Source #

C T Source # 

Methods

abs :: T -> T Source #

signum :: T -> T Source #

(C a, C a) => C (T a) Source # 

Methods

abs :: T a -> T a Source #

signum :: T a -> T a Source #

Num a => C (T a) Source # 

Methods

abs :: T a -> T a Source #

signum :: T a -> T a Source #

(C a, C a, C a) => C (T a) Source # 

Methods

abs :: T a -> T a Source #

signum :: T a -> T a Source #

(C a, C a, C a) => C (T a) Source # 

Methods

abs :: T a -> T a Source #

signum :: T a -> T a Source #

C a => C (T a) Source # 

Methods

abs :: T a -> T a Source #

signum :: T a -> T a Source #

C v => C (T a v) Source # 

Methods

abs :: T a v -> T a v Source #

signum :: T a v -> T a v Source #

(Ord i, C a) => C (T i a) Source # 

Methods

abs :: T i a -> T i a Source #

signum :: T i a -> T i a Source #

C v => C (T a v) Source # 

Methods

abs :: T a v -> T a v Source #

signum :: T a v -> T a v Source #

absOrd :: (C a, Ord a) => a -> a Source #

signumOrd :: (C a, Ord a) => a -> a Source #