Safe Haskell | None |
---|

# Documentation

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`

.

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

Num a => C (T a) | |

(C a, C a, C 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) |