{-# LANGUAGE CPP, PackageImports #-} #if __GLASGOW_HASKELL__ >= 701 {-# LANGUAGE Safe #-} #endif module Data.Ratio ( Ratio , Rational , (%) -- :: (Integral a) => a -> a -> Ratio a , numerator -- :: (Integral a) => Ratio a -> a , denominator -- :: (Integral a) => Ratio a -> a , approxRational -- :: (RealFrac a) => a -> a -> Rational -- * Specification -- \$code ) where import "base" Data.Ratio {- \$code > module Data.Ratio ( > Ratio, Rational, (%), numerator, denominator, approxRational ) where > > infixl 7 % > > ratPrec = 7 :: Int > > data (Integral a) => Ratio a = !a :% !a deriving (Eq) > type Rational = Ratio Integer > > (%) :: (Integral a) => a -> a -> Ratio a > numerator, denominator :: (Integral a) => Ratio a -> a > approxRational :: (RealFrac a) => a -> a -> Rational > > > -- "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. > -- > -- E.g., 12 `reduce` 8 == 3 :% 2 > -- 12 `reduce` (-8) == 3 :% (-2) > > reduce _ 0 = error "Data.Ratio.% : zero denominator" > reduce x y = (x `quot` d) :% (y `quot` d) > where d = gcd x y > > x % y = reduce (x * signum y) (abs y) > > numerator (x :% _) = x > > denominator (_ :% y) = y > > > instance (Integral a) => Ord (Ratio a) where > (x:%y) <= (x':%y') = x * y' <= x' * y > (x:%y) < (x':%y') = x * y' < x' * y > > instance (Integral a) => Num (Ratio a) where > (x:%y) + (x':%y') = reduce (x*y' + x'*y) (y*y') > (x:%y) * (x':%y') = reduce (x * x') (y * y') > negate (x:%y) = (-x) :% y > abs (x:%y) = abs x :% y > signum (x:%y) = signum x :% 1 > fromInteger x = fromInteger x :% 1 > > instance (Integral a) => Real (Ratio a) where > toRational (x:%y) = toInteger x :% toInteger y > > instance (Integral a) => Fractional (Ratio a) where > (x:%y) / (x':%y') = (x*y') % (y*x') > recip (x:%y) = y % x > fromRational (x:%y) = fromInteger x :% fromInteger y > > instance (Integral a) => RealFrac (Ratio a) where > properFraction (x:%y) = (fromIntegral q, r:%y) > where (q,r) = quotRem x y > > instance (Integral a) => Enum (Ratio a) where > succ x = x+1 > pred x = x-1 > toEnum = fromIntegral > fromEnum = fromInteger . truncate -- May overflow > enumFrom = numericEnumFrom -- These numericEnumXXX functions > enumFromThen = numericEnumFromThen -- are as defined in Prelude.hs > enumFromTo = numericEnumFromTo -- but not exported from it! > enumFromThenTo = numericEnumFromThenTo > > instance (Read a, Integral a) => Read (Ratio a) where > readsPrec p = readParen (p > ratPrec) > (\r -> [(x%y,u) | (x,s) <- readsPrec (ratPrec+1) r, > ("%",t) <- lex s, > (y,u) <- readsPrec (ratPrec+1) t ]) > > instance (Integral a) => Show (Ratio a) where > showsPrec p (x:%y) = showParen (p > ratPrec) > showsPrec (ratPrec+1) x . > showString " % " . > showsPrec (ratPrec+1) y) > > > > approxRational x eps = simplest (x-eps) (x+eps) > where simplest x y | y < x = simplest y x > | x == y = xr > | x > 0 = simplest' n d n' d' > | y < 0 = - simplest' (-n') d' (-n) d > | otherwise = 0 :% 1 > where xr@(n:%d) = toRational x > (n':%d') = toRational y > > simplest' n d n' d' -- assumes 0 < n%d < n'%d' > | r == 0 = q :% 1 > | q /= q' = (q+1) :% 1 > | otherwise = (q*n''+d'') :% n'' > where (q,r) = quotRem n d > (q',r') = quotRem n' d' > (n'':%d'') = simplest' d' r' d r -}