Safe Haskell  Safe 

Language  Haskell98 
 class C a => C a where
 div, mod :: C a => a > a > a
 div, mod :: C a => a > a > a
 divMod :: C a => a > a > (a, a)
 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
 divChecked :: (C a, C a) => a > a > a
 safeDiv :: (C a, C a) => a > a > a
 even :: (C a, C a) => a > Bool
 odd :: (C a, C a) => a > Bool
 divUp :: C a => a > a > a
 roundDown :: C a => a > a > a
 roundUp :: C a => a > a > a
 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
class C a => C a where Source #
IntegralDomain
corresponds to a commutative ring,
where a
picks a canonical element
of the equivalence class of mod
ba
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.
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 #  
Integral a => C (T a) Source #  
(Ord a, C a, C a) => C (T a) Source # 

(C a, C a) => C (T a) Source #  
(C a, C a) => C (T a) Source #  The 
C a => C (T a) Source #  
C a => C (T a) Source #  
Derived functions
divModZero :: (C a, C a) => a > a > (a, a) Source #
Allows division by zero. If the divisor is zero, then the dividend is returned as remainder.
divChecked :: (C a, C a) => a > a > a Source #
Returns the result of the division, if divisible. Otherwise undefined.
safeDiv :: (C a, C a) => a > a > a Source #
Deprecated: use divChecked instead
Returns the result of the division, if divisible. Otherwise undefined.
divUp :: C a => a > a > a Source #
divUp n m
is similar to div
but it rounds up the quotient,
such that divUp n m * m = roundUp n m
.
roundDown :: C a => a > a > a Source #
roundDown n m
rounds n
down to the next multiple of m
.
That is, roundDown n m
is the greatest multiple of m
that is at most n
.
The parameter order is consistent with div
and friends,
but maybe not useful for partial application.
roundUp :: C a => a > a > a Source #
roundUp n m
rounds n
up to the next multiple of m
.
That is, roundUp n m
is the greatest multiple of m
that is at most n
.
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 #