Copyright | (c) The University of Glasgow 1994-2002 |
---|---|
License | see libraries/base/LICENSE |
Maintainer | [email protected] |
Stability | internal |
Portability | non-portable (GHC Extensions) |
Safe Haskell | Trustworthy |
Language | Haskell2010 |
divZeroError :: a Source
ratioZeroDenominatorError :: a Source
overflowError :: a Source
underflowError :: a Source
Rational numbers, with numerator and denominator of some Integral
type.
Note that Ratio
's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural
's Num
instance has similar problems to Natural
's.
!a :% !a |
Integral a => Enum (Ratio a) | Since: base-2.0.1 |
Defined in GHC.Real Methodssucc :: Ratio a -> Ratio a Source pred :: Ratio a -> Ratio a Source toEnum :: Int -> Ratio a Source fromEnum :: Ratio a -> Int Source enumFrom :: Ratio a -> [Ratio a] Source enumFromThen :: Ratio a -> Ratio a -> [Ratio a] Source enumFromTo :: Ratio a -> Ratio a -> [Ratio a] Source enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] Source | |
Eq a => Eq (Ratio a) | Since: base-2.1 |
Integral a => Fractional (Ratio a) | Since: base-2.0.1 |
(Data a, Integral a) => Data (Ratio a) | Since: base-4.0.0.0 |
Defined in Data.Data Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) Source toConstr :: Ratio a -> Constr Source dataTypeOf :: Ratio a -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) Source gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source | |
Integral a => Num (Ratio a) | Since: base-2.0.1 |
Defined in GHC.Real | |
Integral a => Ord (Ratio a) | Since: base-2.0.1 |
(Integral a, Read a) => Read (Ratio a) | Since: base-2.1 |
Integral a => Real (Ratio a) | Since: base-2.0.1 |
Defined in GHC.Real MethodstoRational :: Ratio a -> Rational Source | |
Integral a => RealFrac (Ratio a) | Since: base-2.0.1 |
Show a => Show (Ratio a) | Since: base-2.0.1 |
(Storable a, Integral a) => Storable (Ratio a) | Since: base-4.8.0.0 |
Defined in Foreign.Storable MethodssizeOf :: Ratio a -> Int Source alignment :: Ratio a -> Int Source peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) Source pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () Source peekByteOff :: Ptr b -> Int -> IO (Ratio a) Source pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () Source |
type Rational = Ratio Integer Source
Arbitrary-precision rational numbers, represented as a ratio of two Integer
values. A rational number may be constructed using the %
operator.
ratioPrec1 :: Int Source
(%) :: Integral a => a -> a -> Ratio a infixl 7 Source
Forms the ratio of two integral numbers.
numerator :: Ratio a -> a Source
Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.
denominator :: Ratio a -> a Source
Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.
reduce :: Integral a => a -> a -> Ratio a Source
reduce
is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.
class (Num a, Ord a) => Real a where Source
toRational :: a -> Rational Source
the rational equivalent of its real argument with full precision
class (Real a, Enum a) => Integral a where Source
Integral numbers, supporting integer division.
The Haskell Report defines no laws for Integral
. However, Integral
instances are customarily expected to define a Euclidean domain and have the following properties for the div
/mod
and quot
/rem
pairs, given suitable Euclidean functions f
and g
:
x
= y * quot x y + rem x y
with rem x y
= fromInteger 0
or g (rem x y)
< g y
x
= y * div x y + mod x y
with mod x y
= fromInteger 0
or f (mod x y)
< f y
An example of a suitable Euclidean function, for Integer
's instance, is abs
.
quot :: a -> a -> a infixl 7 Source
integer division truncated toward zero
rem :: a -> a -> a infixl 7 Source
integer remainder, satisfying
(x `quot` y)*y + (x `rem` y) == x
div :: a -> a -> a infixl 7 Source
integer division truncated toward negative infinity
mod :: a -> a -> a infixl 7 Source
integer modulus, satisfying
(x `div` y)*y + (x `mod` y) == x
quotRem :: a -> a -> (a, a) Source
divMod :: a -> a -> (a, a) Source
toInteger :: a -> Integer Source
conversion to Integer
class Num a => Fractional a where Source
Fractional numbers, supporting real division.
The Haskell Report defines no laws for Fractional
. However, (+)
and (*)
are customarily expected to define a division ring and have the following properties:
recip
gives the multiplicative inversex * recip x
= recip x * x
= fromInteger 1
Note that it isn't customarily expected that a type instance of Fractional
implement a field. However, all instances in base
do.
fromRational, (recip | (/))
(/) :: a -> a -> a infixl 7 Source
Fractional division.
Reciprocal fraction.
fromRational :: Rational -> a Source
Conversion from a Rational
(that is Ratio Integer
). A floating literal stands for an application of fromRational
to a value of type Rational
, so such literals have type (Fractional a) => a
.
Fractional Double |
Note that due to the presence of >>> 0/0 * (recip 0/0 :: Double) NaN Since: base-2.1 |
Fractional Float |
Note that due to the presence of >>> 0/0 * (recip 0/0 :: Float) NaN Since: base-2.1 |
Fractional CDouble | |
Fractional CFloat | |
Integral a => Fractional (Ratio a) | Since: base-2.0.1 |
Fractional a => Fractional (Identity a) | Since: base-4.9.0.0 |
HasResolution a => Fractional (Fixed a) | Since: base-2.1 |
RealFloat a => Fractional (Complex a) | Since: base-2.1 |
Fractional a => Fractional (Op a b) | |
Fractional a => Fractional (Const a b) | Since: base-4.9.0.0 |
class (Real a, Fractional a) => RealFrac a where Source
Extracting components of fractions.
properFraction :: Integral b => a -> (b, a) Source
The function properFraction
takes a real fractional number x
and returns a pair (n,f)
such that x = n+f
, and:
n
is an integral number with the same sign as x
; andf
is a fraction with the same type and sign as x
, and with absolute value less than 1
.The default definitions of the ceiling
, floor
, truncate
and round
functions are in terms of properFraction
.
truncate :: Integral b => a -> b Source
truncate x
returns the integer nearest x
between zero and x
round :: Integral b => a -> b Source
round x
returns the nearest integer to x
; the even integer if x
is equidistant between two integers
ceiling :: Integral b => a -> b Source
ceiling x
returns the least integer not less than x
floor :: Integral b => a -> b Source
floor x
returns the greatest integer not greater than x
RealFrac Double | Since: base-2.1 |
RealFrac Float | Since: base-2.1 |
RealFrac CDouble | |
RealFrac CFloat | |
Integral a => RealFrac (Ratio a) | Since: base-2.0.1 |
RealFrac a => RealFrac (Identity a) | Since: base-4.9.0.0 |
HasResolution a => RealFrac (Fixed a) | Since: base-2.1 |
RealFrac a => RealFrac (Const a b) | Since: base-4.9.0.0 |
numericEnumFrom :: Fractional a => a -> [a] Source
numericEnumFromThen :: Fractional a => a -> a -> [a] Source
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a] Source
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a] Source
fromIntegral :: (Integral a, Num b) => a -> b Source
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b Source
general coercion to fractional types
:: Real a | |
=> (a -> ShowS) | a function that can show unsigned values |
-> Int | the precedence of the enclosing context |
-> a | the value to show |
-> ShowS |
Converts a possibly-negative Real
value to a string.
even :: Integral a => a -> Bool Source
odd :: Integral a => a -> Bool Source
(^) :: (Num a, Integral b) => a -> b -> a infixr 8 Source
raise a number to a non-negative integral power
(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 Source
raise a number to an integral power
(^%^) :: Integral a => Rational -> a -> Rational Source
(^^%^^) :: Integral a => Rational -> a -> Rational Source
gcd :: Integral a => a -> a -> a Source
gcd x y
is the non-negative factor of both x
and y
of which every common factor of x
and y
is also a factor; for example gcd 4 2 = 2
, gcd (-4) 6 = 2
, gcd 0 4
= 4
. gcd 0 0
= 0
. (That is, the common divisor that is "greatest" in the divisibility preordering.)
Note: Since for signed fixed-width integer types, abs minBound < 0
, the result may be negative if one of the arguments is minBound
(and necessarily is if the other is 0
or minBound
) for such types.
lcm :: Integral a => a -> a -> a Source
lcm x y
is the smallest positive integer that both x
and y
divide.
gcdInt' :: Int -> Int -> Int Source
gcdWord' :: Word -> Word -> Word Source
integralEnumFrom :: (Integral a, Bounded a) => a -> [a] Source
integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a] Source
integralEnumFromTo :: Integral a => a -> a -> [a] Source
integralEnumFromThenTo :: Integral a => a -> a -> a -> [a] Source
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/GHC-Real.html