| Safe Haskell | None |
|---|---|
| Language | Haskell98 |
NumericPrelude.Numeric
Synopsis
- (+), (-) :: C a => a -> a -> a
- (+), (-) :: C a => a -> a -> a
- negate :: C a => a -> a
- zero :: C a => a
- subtract :: C a => a -> a -> a
- sum :: C a => [a] -> a
- sum1 :: C a => [a] -> a
- isZero :: C a => a -> Bool
- (*) :: C a => a -> a -> a
- one :: C a => a
- fromInteger :: C a => Integer -> a
- (^) :: C a => a -> Integer -> a
- ringPower :: (C a, C b) => b -> a -> a
- sqr :: C a => a -> a
- product :: C a => [a] -> a
- product1 :: C a => [a] -> a
- div, mod :: C a => a -> a -> a
- div, mod :: C a => a -> a -> a
- divMod :: C a => a -> a -> (a, a)
- divides :: (C a, C a) => a -> a -> Bool
- even :: (C a, C a) => a -> Bool
- odd :: (C a, C a) => a -> Bool
- (/) :: C a => a -> a -> a
- recip :: C a => a -> a
- fromRational' :: C a => Rational -> a
- (^-) :: C a => a -> Integer -> a
- fieldPower :: (C a, C b) => b -> a -> a
- fromRational :: C a => Rational -> a
- (^/) :: C a => a -> Rational -> a
- sqrt :: C a => a -> a
- pi :: C a => a
- exp, log :: C a => a -> a
- exp, log :: C a => a -> a
- logBase, (**) :: C a => a -> a -> a
- logBase, (**) :: C a => a -> a -> a
- (^?) :: C a => a -> a -> a
- sin, cos, tan :: C a => a -> a
- sin, cos, tan :: C a => a -> a
- sin, cos, tan :: C a => a -> a
- asin, acos, atan :: C a => a -> a
- asin, acos, atan :: C a => a -> a
- asin, acos, atan :: C a => a -> a
- sinh, cosh, tanh :: C a => a -> a
- sinh, cosh, tanh :: C a => a -> a
- sinh, cosh, tanh :: C a => a -> a
- asinh, acosh, atanh :: C a => a -> a
- asinh, acosh, atanh :: C a => a -> a
- asinh, acosh, atanh :: C a => a -> a
- abs :: C a => a -> a
- signum :: C a => a -> a
- quot, rem :: C a => a -> a -> a
- quot, rem :: C a => a -> a -> a
- quotRem :: C a => a -> a -> (a, a)
- splitFraction :: (C a, C b) => a -> (b, a)
- fraction :: C a => a -> a
- truncate :: (C a, C b) => a -> b
- round :: (C a, C b) => a -> b
- ceiling, floor :: (C a, C b) => a -> b
- ceiling, floor :: (C a, C b) => a -> b
- approxRational :: (C a, C a) => a -> a -> Rational
- atan2 :: C a => a -> a -> a
- toRational :: C a => a -> Rational
- toInteger :: C a => a -> Integer
- fromIntegral :: (C a, C b) => a -> b
- isUnit :: C a => a -> Bool
- stdAssociate, stdUnit, stdUnitInv :: C a => a -> a
- stdAssociate, stdUnit, stdUnitInv :: C a => a -> a
- stdAssociate, stdUnit, stdUnitInv :: C a => a -> a
- extendedGCD :: C a => a -> a -> (a, (a, a))
- gcd :: C a => a -> a -> a
- lcm :: C a => a -> a -> a
- euclid :: (C a, C a) => (a -> a -> a) -> a -> a -> a
- extendedEuclid :: (C a, C a) => (a -> a -> (a, a)) -> a -> a -> (a, (a, a))
- type Rational = T Integer
- (%) :: C a => a -> a -> T a
- numerator :: T a -> a
- denominator :: T a -> a
- data Integer
- data Int
- data Float
- data Double
- (*>) :: C a v => a -> v -> v
Documentation
subtract :: C a => a -> a -> a Source #
subtract is (-) with swapped operand order.
This is the operand order which will be needed in most cases
of partial application.
sum :: C a => [a] -> a Source #
Sum up all elements of a list. An empty list yields zero.
This function is inappropriate for number types like Peano.
Maybe we should make sum a method of Additive.
This would also make lengthLeft and lengthRight superfluous.
sum1 :: C a => [a] -> a Source #
Sum up all elements of a non-empty list. This avoids including a zero which is useful for types where no universal zero is available. ToDo: Should have NonEmpty type.
\(QC.NonEmpty ns) -> A.sum ns == (A.sum1 ns :: Integer)
fromInteger :: C a => Integer -> a Source #
(^) :: C a => a -> Integer -> a infixr 8 Source #
The exponent has fixed type Integer in order
to avoid an arbitrarily limitted range of exponents,
but to reduce the need for the compiler to guess the type (default type).
In practice the exponent is most oftenly fixed, and is most oftenly 2.
Fixed exponents can be optimized away and
thus the expensive computation of Integers doesn't matter.
The previous solution used a C constrained type
and the exponent was converted to Integer before computation.
So the current solution is not less efficient.
A variant of ^ with more flexibility is provided by ringPower.
ringPower :: (C a, C b) => b -> a -> a Source #
A prefix function of (^)
with a parameter order that fits the needs of partial application
and function composition.
It has generalised exponent.
See: Argument order of expNat on
http://www.haskell.org/pipermail/haskell-cafe/2006-September/018022.html
divMod :: C a => a -> a -> (a, a) Source #
\n (QC.NonZero m) -> let (q,r) = divMod n m in n == (q*m+r :: Integer)
fromRational' :: C a => Rational -> a Source #
fieldPower :: (C a, C b) => b -> a -> a Source #
A prefix function of (^-).
It has a generalised exponent.
fromRational :: C a => Rational -> a Source #
Needed to work around shortcomings in GHC.
splitFraction :: (C a, C b) => a -> (b, a) Source #
\x -> (x::Rational) == (uncurry (+) $ mapFst fromInteger $ splitFraction x)
\x -> uncurry (==) $ mapFst (((x::Double)-) . fromInteger) $ splitFraction x
\x -> uncurry (==) $ mapFst (((x::Rational)-) . fromInteger) $ splitFraction x
\x -> splitFraction x == (floor (x::Double) :: Integer, fraction x)
\x -> splitFraction x == (floor (x::Rational) :: Integer, fraction x)
fraction :: C a => a -> a Source #
\x -> let y = fraction (x::Double) in 0<=y && y<1
\x -> let y = fraction (x::Rational) in 0<=y && y<1
ceiling, floor :: (C a, C b) => a -> b Source #
\x -> ceiling (-x) == negate (floor (x::Double) :: Integer)
\x -> ceiling (-x) == negate (floor (x::Rational) :: Integer)
ceiling, floor :: (C a, C b) => a -> b Source #
\x -> ceiling (-x) == negate (floor (x::Double) :: Integer)
\x -> ceiling (-x) == negate (floor (x::Rational) :: Integer)
approxRational :: (C a, C a) => a -> a -> Rational Source #
TODO: Should be moved to a continued fraction module.
toRational :: C a => a -> Rational Source #
Lossless conversion from any representation of a rational to Rational
fromIntegral :: (C a, C b) => a -> b Source #
stdAssociate, stdUnit, stdUnitInv :: C a => a -> a Source #
stdAssociate, stdUnit, stdUnitInv :: C a => a -> a Source #
stdAssociate, stdUnit, stdUnitInv :: C a => a -> a Source #
extendedGCD :: C a => a -> a -> (a, (a, a)) Source #
Compute the greatest common divisor and solve a respective Diophantine equation.
(g,(a,b)) = extendedGCD x y ==>
g==a*x+b*y && g == gcd x yTODO: This method is not appropriate for the PID class, because there are rings like the one of the multivariate polynomials, where for all x and y greatest common divisors of x and y exist, but they cannot be represented as a linear combination of x and y. TODO: The definition of extendedGCD does not return the canonical associate.
gcd :: C a => a -> a -> a Source #
The Greatest Common Divisor is defined by:
gcd x y == gcd y x divides z x && divides z y ==> divides z (gcd x y) (specification) divides (gcd x y) x
extendedEuclid :: (C a, C a) => (a -> a -> (a, a)) -> a -> a -> (a, (a, a)) Source #
denominator :: T a -> a Source #
Arbitrary precision integers. In contrast with fixed-size integral types
such as Int, the Integer type represents the entire infinite range of
integers.
For more information about this type's representation, see the comments in its implementation.
Instances
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1].
The exact range for a given implementation can be determined by using
minBound and maxBound from the Bounded class.
Instances
| Bounded Int | Since: base-2.1 |
| Enum Int | Since: base-2.1 |
| Eq Int | |
| Integral Int | Since: base-2.0.1 |
| Num Int | Since: base-2.1 |
| Ord Int | |
| Read Int | Since: base-2.1 |
| Real Int | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Show Int | Since: base-2.1 |
| Ix Int | Since: base-2.1 |
| Arbitrary Int | |
| CoArbitrary Int | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b # | |
| Storable Int | Since: base-2.1 |
Defined in Foreign.Storable | |
| NFData Int | |
Defined in Control.DeepSeq | |
| Random Int | |
| Uniform Int | |
Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int # | |
| UniformRange Int | |
Defined in System.Random.Internal | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
Defined in Algebra.ToRational Methods toRational :: Int -> Rational Source # | |
| C Int Source # | |
| C Int Source # | |
| C Int Source # | |
| Lift Int | |
| C Int Int Source # | |
| C Int Int Source # | |
| C Int Int Source # | |
| C Int Int Source # | |
| C Int Int Source # | |
| Sqr Int Int Source # | |
| Generic1 (URec Int :: k -> Type) | Since: base-4.9.0.0 |
| Foldable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
| Traversable (UInt :: Type -> Type) | Since: base-4.9.0.0 |
| Functor (URec Int :: Type -> Type) | Since: base-4.9.0.0 |
| Eq (URec Int p) | Since: base-4.9.0.0 |
| Ord (URec Int p) | Since: base-4.9.0.0 |
| Show (URec Int p) | Since: base-4.9.0.0 |
| Generic (URec Int p) | Since: base-4.9.0.0 |
| data URec Int (p :: k) | Used for marking occurrences of Since: base-4.9.0.0 |
| type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Int p) | |
Defined in GHC.Generics | |
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
Instances
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.