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

.