Module

# Data.DivisionRing

Package
purescript-prelude
Repository
purescript/purescript-prelude

### #DivisionRingSource

``class (Ring a) <= DivisionRing a  where``

The `DivisionRing` class is for non-zero rings in which every non-zero element has a multiplicative inverse. Division rings are sometimes also called skew fields.

Instances must satisfy the following laws in addition to the `Ring` laws:

• Non-zero ring: `one /= zero`
• Non-zero multiplicative inverse: `recip a * a = a * recip a = one` for all non-zero `a`

The result of `recip zero` is left undefined; individual instances may choose how to handle this case.

If a type has both `DivisionRing` and `CommutativeRing` instances, then it is a field and should have a `Field` instance.

#### Members

• `recip :: a -> a`

#### Instances

• `DivisionRing Number`

### #leftDivSource

``leftDiv :: forall a. DivisionRing a => a -> a -> a``

Left division, defined as `leftDiv a b = recip b * a`. Left and right division are distinct in this module because a `DivisionRing` is not necessarily commutative.

If the type `a` is also a `EuclideanRing`, then this function is equivalent to `div` from the `EuclideanRing` class. When working abstractly, `div` should generally be preferred, unless you know that you need your code to work with noncommutative rings.

### #rightDivSource

``rightDiv :: forall a. DivisionRing a => a -> a -> a``

Right division, defined as `rightDiv a b = a * recip b`. Left and right division are distinct in this module because a `DivisionRing` is not necessarily commutative.

If the type `a` is also a `EuclideanRing`, then this function is equivalent to `div` from the `EuclideanRing` class. When working abstractly, `div` should generally be preferred, unless you know that you need your code to work with noncommutative rings.

## Re-exports from Data.Ring

### #RingSource

``class (Semiring a) <= Ring a  where``

The `Ring` class is for types that support addition, multiplication, and subtraction operations.

Instances must satisfy the following law in addition to the `Semiring` laws:

• Additive inverse: `a - a = (zero - a) + a = zero`

#### Members

• `sub :: a -> a -> a`

#### Instances

• `Ring Int`
• `Ring Number`
• `Ring Unit`
• `(Ring b) => Ring (a -> b)`

### #negateSource

``negate :: forall a. Ring a => a -> a``

`negate x` can be used as a shorthand for `zero - x`.

## Re-exports from Data.Semiring

### #SemiringSource

``class Semiring a  where``

The `Semiring` class is for types that support an addition and multiplication operation.

Instances must satisfy the following laws:

• Commutative monoid under addition:
• Associativity: `(a + b) + c = a + (b + c)`
• Identity: `zero + a = a + zero = a`
• Commutative: `a + b = b + a`
• Monoid under multiplication:
• Associativity: `(a * b) * c = a * (b * c)`
• Identity: `one * a = a * one = a`
• Multiplication distributes over addition:
• Left distributivity: `a * (b + c) = (a * b) + (a * c)`
• Right distributivity: `(a + b) * c = (a * c) + (b * c)`
• Annihilation: `zero * a = a * zero = zero`

Note: The `Number` and `Int` types are not fully law abiding members of this class hierarchy due to the potential for arithmetic overflows, and in the case of `Number`, the presence of `NaN` and `Infinity` values. The behaviour is unspecified in these cases.

#### Members

• `add :: a -> a -> a`
• `zero :: a`
• `mul :: a -> a -> a`
• `one :: a`

#### Instances

• `Semiring Int`
• `Semiring Number`
• `(Semiring b) => Semiring (a -> b)`
• `Semiring Unit`

### #(+)Source

Operator alias for Data.Semiring.add (left-associative / precedence 6)

### #(*)Source

Operator alias for Data.Semiring.mul (left-associative / precedence 7)