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

Algebra.Absolute

Synopsis

# Documentation

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

Methods

abs :: a -> aSource

signum :: a -> aSource

Instances

 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