Safe Haskell | Safe |
---|---|

Language | Haskell98 |

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

.

C Double Source # | |

C Float Source # | |

C Int Source # | |

C Int8 Source # | |

C Int16 Source # | |

C Int32 Source # | |

C Int64 Source # | |

C Integer Source # | |

C Word Source # | |

C Word8 Source # | |

C Word16 Source # | |

C Word32 Source # | |

C Word64 Source # | |

C T Source # | |

C T Source # | |

C T Source # | |

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

Num a => C (T a) Source # | |

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

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

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

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

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

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