Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell98 |
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) |