-- !! fromRational woes
import Data.Ratio -- 1.3

main = putStr (
   shows tinyFloat  ( '\n'
 : shows t_f	    ( '\n'
 : shows hugeFloat  ( '\n'
 : shows h_f	    ( '\n'
 : shows tinyDouble ( '\n'
 : shows t_d	    ( '\n'
 : shows hugeDouble ( '\n'
 : shows h_d	    ( '\n'
 : shows x_f	    ( '\n'
 : shows x_d	    ( '\n'
 : shows y_f	    ( '\n'
 : shows y_d	    ( "\n"
 )))))))))))))
  where
    t_f :: Float
    t_d :: Double
    h_f :: Float
    h_d :: Double
    x_f :: Float
    x_d :: Double
    y_f :: Float
    y_d :: Double
    t_f = fromRationalX (toRational tinyFloat)
    t_d = fromRationalX (toRational tinyDouble)
    h_f = fromRationalX (toRational hugeFloat)
    h_d = fromRationalX (toRational hugeDouble)
    x_f = fromRationalX (1.82173691287639817263897126389712638972163e-300 :: Rational)
    x_d = fromRationalX (1.82173691287639817263897126389712638972163e-300 :: Rational)
    y_f = 1.82173691287639817263897126389712638972163e-300
    y_d = 1.82173691287639817263897126389712638972163e-300

fromRationalX :: (RealFloat a) => Rational -> a
fromRationalX r =
	let 
	    h = ceiling (huge `asTypeOf` x)
	    b = toInteger (floatRadix x)
	    x = fromRat 0 r
	    fromRat e0 r' =
		let d = denominator r'
		    n = numerator r'
	        in  if d > h then
		       let e = integerLogBase b (d `div` h) + 1
		       in  fromRat (e0-e) (n % (d `div` (b^e)))
		    else if abs n > h then
		       let e = integerLogBase b (abs n `div` h) + 1
		       in  fromRat (e0+e) ((n `div` (b^e)) % d)
		    else
		       scaleFloat e0 (rationalToRealFloat {-fromRational-} r')
	in  x

{-
fromRationalX r =
  rationalToRealFloat r
{- Hmmm...
	let 
	    h = ceiling (huge `asTypeOf` x)
	    b = toInteger (floatRadix x)
	    x = fromRat 0 r

	    fromRat e0 r' =
{--}		trace (shows e0 ('/' : shows r' ('/' : shows h "\n"))) (
		let d = denominator r'
		    n = numerator r'
	        in  if d > h then
		       let e = integerLogBase b (d `div` h) + 1
		       in  fromRat (e0-e) (n % (d `div` (b^e)))
		    else if abs n > h then
		       let e = integerLogBase b (abs n `div` h) + 1
		       in  fromRat (e0+e) ((n `div` (b^e)) % d)
		    else
		       scaleFloat e0 (rationalToRealFloat r')
		       -- now that we know things are in-bounds,
		       -- we use the "old" Prelude code.
{--}		)
	in  x
-}
-}

-- Compute the discrete log of i in base b.
-- Simplest way would be just divide i by b until it's smaller then b, but that would
-- be very slow!  We are just slightly more clever.
integerLogBase :: Integer -> Integer -> Int
integerLogBase b i =
     if i < b then
        0
     else
	-- Try squaring the base first to cut down the number of divisions.
        let l = 2 * integerLogBase (b*b) i
	    doDiv :: Integer -> Int -> Int
	    doDiv i l = if i < b then l else doDiv (i `div` b) (l+1)
	in  doDiv (i `div` (b^l)) l


------------

-- Compute smallest and largest floating point values.
tiny :: (RealFloat a) => a
tiny =
	let (l, _) = floatRange x
	    x = encodeFloat 1 (l-1)
	in  x

huge :: (RealFloat a) => a
huge =
	let (_, u) = floatRange x
	    d = floatDigits x
	    x = encodeFloat (floatRadix x ^ d - 1) (u - d)
	in  x

tinyDouble = tiny :: Double
tinyFloat  = tiny :: Float
hugeDouble = huge :: Double
hugeFloat  = huge :: Float

{-
[In response to a request by simonpj, Joe Fasel writes:]

A quite reasonable request!  This code was added to the Prelude just
before the 1.2 release, when Lennart, working with an early version
of hbi, noticed that (read . show) was not the identity for
floating-point numbers.	 (There was a one-bit error about half the time.)
The original version of the conversion function was in fact simply
a floating-point divide, as you suggest above.	The new version is,
I grant you, somewhat denser.

How's this?

--Joe
-}


rationalToRealFloat :: (RealFloat a) => Rational -> a

rationalToRealFloat x	=  x'
	where x'    = f e

--		If the exponent of the nearest floating-point number to x 
--		is e, then the significand is the integer nearest xb^(-e),
--		where b is the floating-point radix.  We start with a good
--		guess for e, and if it is correct, the exponent of the
--		floating-point number we construct will again be e.  If
--		not, one more iteration is needed.

	      f e   = if e' == e then y else f e'
		      where y	   = encodeFloat (round (x * (1%b)^^e)) e
			    (_,e') = decodeFloat y
	      b	    = floatRadix x'

--		We obtain a trial exponent by doing a floating-point
--		division of x's numerator by its denominator.  The
--		result of this division may not itself be the ultimate
--		result, because of an accumulation of three rounding
--		errors.

	      (s,e) = decodeFloat (fromInteger (numerator x) `asTypeOf` x'
					/ fromInteger (denominator x))