- class C a => C a where
- divModZero :: (C a, C a) => a -> a -> (a, a)
- divides :: (C a, C a) => a -> a -> Bool
- sameResidueClass :: (C a, C a) => a -> a -> a -> Bool
- safeDiv :: (C a, C a) => a -> a -> a
- even :: (C a, C a) => a -> Bool
- odd :: (C a, C a) => a -> Bool
- decomposeVarPositional :: (C a, C a) => [a] -> a -> [a]
- decomposeVarPositionalInf :: C a => [a] -> a -> [a]
- propInverse :: (Eq a, C a, C a) => a -> a -> Property
- propMultipleDiv :: (Eq a, C a, C a) => a -> a -> Property
- propMultipleMod :: (Eq a, C a, C a) => a -> a -> Property
- propProjectAddition :: (Eq a, C a, C a) => a -> a -> a -> Property
- propProjectMultiplication :: (Eq a, C a, C a) => a -> a -> a -> Property
- propUniqueRepresentative :: (Eq a, C a, C a) => a -> a -> a -> Property
- propZeroRepresentative :: (Eq a, C a, C a) => a -> Property
- propSameResidueClass :: (Eq a, C a, C a) => a -> a -> a -> Property

# Class

`IntegralDomain`

corresponds to a commutative ring,
where `a `

picks a canonical element
of the equivalence class of `mod`

b`a`

in the ideal generated by `b`

.
`div`

and `mod`

satisfy the laws

a * b === b * a (a `div` b) * b + (a `mod` b) === a (a+k*b) `mod` b === a `mod` b 0 `mod` b === 0

Typical examples of `IntegralDomain`

include integers and
polynomials over a field.
Note that for a field, there is a canonical instance
defined by the above rules; e.g.,

instance IntegralDomain.C Rational where divMod a b = if isZero b then (undefined,a) else (a\/b,0)

It shall be noted, that `div`

, `mod`

, `divMod`

have a parameter order
which is unfortunate for partial application.
But it is adapted to mathematical conventions,
where the operators are used in infix notation.

# Derived functions

divModZero :: (C a, C a) => a -> a -> (a, a)Source

Allows division by zero. If the divisor is zero, then the divident is returned as remainder.

sameResidueClass :: (C a, C a) => a -> a -> a -> BoolSource

safeDiv :: (C a, C a) => a -> a -> aSource

Returns the result of the division, if divisible. Otherwise undefined.

# Algorithms

decomposeVarPositional :: (C a, C a) => [a] -> a -> [a]Source

`decomposeVarPositional [b0,b1,b2,...] x`

decomposes `x`

into a positional representation with mixed bases
`x0 + b0*(x1 + b1*(x2 + b2*x3))`

E.g. `decomposeVarPositional (repeat 10) 123 == [3,2,1]`

decomposeVarPositionalInf :: C a => [a] -> a -> [a]Source