div package:numeric-prelude

div :: C a => a -> a -> a
numeric-prelude Algebra.IntegralDomain Algebra.IntegralDomain NumericPrelude NumericPrelude NumericPrelude.Numeric NumericPrelude.Numeric
div :: (C a, C a) => T a -> T a -> T a
numeric-prelude MathObj.LaurentPolynomial
div :: C a => T a -> T a -> T a
numeric-prelude Number.Root
Div :: T a v -> T a v -> Term a v
numeric-prelude Number.OccasionallyScalarExpression
divChecked :: (C a, C a) => a -> a -> a
numeric-prelude Algebra.IntegralDomain
Returns the result of the division, if divisible. Otherwise undefined.
divMod :: C a => a -> a -> (a, a)
numeric-prelude Algebra.IntegralDomain
\n (QC.NonZero m) -> let (q,r) = divMod n m in n == (q*m+r :: Integer)
divModZero :: (C a, C a) => a -> a -> (a, a)
numeric-prelude Algebra.IntegralDomain
Allows division by zero. If the divisor is zero, then the dividend is returned as remainder.
divUp :: C a => a -> a -> a
numeric-prelude Algebra.IntegralDomain
divUp n m is similar to div but it rounds up the quotient, such that divUp n m * m = roundUp n m.
divides :: (C a, C a) => a -> a -> Bool
numeric-prelude Algebra.IntegralDomain
divExample :: T Rational
numeric-prelude MathObj.LaurentPolynomial
divMod :: (C a, C a) => [a] -> [a] -> ([a], [a])
numeric-prelude MathObj.Polynomial.Core
\x y -> case (PolyCore.normalize x, PolyCore.normalize y) of (nx, ny) -> not (null (ratioPoly ny)) ==> mapSnd PolyCore.normalize (PolyCore.divMod nx ny) == mapPair (PolyCore.normalize, PolyCore.normalize) (PolyCore.divMod x y)

\x y -> not (isZero (ratioPoly y)) ==> let z = fst $ PolyCore.divMod (Poly.coeffs x) y in  PolyCore.normalize z == z

\x y -> case PolyCore.normalize $ ratioPoly y of ny -> not (null ny) ==> List.length (snd $ PolyCore.divMod x y) < List.length ny
divModRev :: (C a, C a) => [a] -> [a] -> ([a], [a])
numeric-prelude MathObj.Polynomial.Core
The modulus will always have one element less than the divisor. This means that the modulus will be denormalized in some cases, e.g. mod [2,1,1] [1,1,1] == [1,0] instead of [1].
divMod :: (C a, C a) => [a] -> [a] -> ([a], [a])
numeric-prelude MathObj.PowerSeries.Core
divide :: C a => [a] -> [a] -> [a]
numeric-prelude MathObj.PowerSeries.Core
Divide two series where the absolute term of the divisor is non-zero. That is, power series with leading non-zero terms are the units in the ring of power series. Knuth: Seminumerical algorithms
divideStripZero :: (C a, C a) => [a] -> [a] -> [a]
numeric-prelude MathObj.PowerSeries.Core
Divide two series also if the divisor has leading zeros.
divide :: C a => T a -> T a -> T a
numeric-prelude MathObj.PowerSeries2.Core
divOneFlip :: (Eq a, C a) => [a] -> [a] -> [a]
numeric-prelude MathObj.PowerSum
divToScalar :: (C u, C a) => T u a -> T u a -> a
numeric-prelude Number.DimensionTerm
divide :: Integer -> Integer -> Integer -> Integer
numeric-prelude Number.FixedPoint
divModLazy :: (C a, C a) => T a -> T a -> (T a, T a)
numeric-prelude Number.NonNegativeChunky
divModLazy accesses the divisor in a lazy way. However this is only relevant if the dividend is smaller than the divisor. For large dividends the divisor will be accessed multiple times but since it is already fully evaluated it could also be strict.
divModStrict :: (C a, C a) => T a -> a -> (T a, a)
numeric-prelude Number.NonNegativeChunky
This function has a strict divisor and maintains the chunk structure of the dividend at a smaller scale.
divInt :: Basis -> Digit -> T -> T
numeric-prelude Number.Positional
divIntMant :: Basis -> Digit -> Mantissa -> Mantissa
numeric-prelude Number.Positional
Fast division for small integral divisors, which occur for instance in summands of power series.
divIntMantInf :: Basis -> Digit -> Mantissa -> Mantissa
numeric-prelude Number.Positional
divMant :: Basis -> Mantissa -> Mantissa -> Mantissa
numeric-prelude Number.Positional