-- ERA: Exact Real Arithmetic (version 1.0)

--

-- A tolerably efficient and possibly correct implementation of the computable

-- reals using Haskell 1.2.

--

-- David Lester, Department of Computer Science, Manchester University, M13 9PL.

--           (2000-2001)


module Data.Number.CReal(CReal, showCReal) where
import Data.Ratio
import Numeric(readFloat, readSigned)

-- |The 'CReal' type implements (constructive) real numbers.

--

-- Note that the comparison operations on 'CReal' may diverge

-- since it is (by necessity) impossible to implementent them

-- correctly and always terminating.

--

-- This implementation is really David Lester's ERA package.

data CReal = CR (Int -> Integer)

instance Eq  CReal where
  CReal
x == :: CReal -> CReal -> Bool
== CReal
y = Int -> Integer
s' (Int -> Int
digitsToBits Int
digits) forall a. Eq a => a -> a -> Bool
== Integer
0 where (CR Int -> Integer
s') = CReal
xforall a. Num a => a -> a -> a
-CReal
y

instance Ord CReal where
  CReal
x <= :: CReal -> CReal -> Bool
<= CReal
y = Int -> Integer
s' (Int -> Int
digitsToBits Int
digits) forall a. Ord a => a -> a -> Bool
<= Integer
0 where (CR Int -> Integer
s') = CReal
xforall a. Num a => a -> a -> a
-CReal
y
  CReal
x < :: CReal -> CReal -> Bool
<  CReal
y = Int -> Integer
s' (Int -> Int
digitsToBits Int
digits) forall a. Ord a => a -> a -> Bool
<  Integer
0 where (CR Int -> Integer
s') = CReal
xforall a. Num a => a -> a -> a
-CReal
y
  CReal
x >= :: CReal -> CReal -> Bool
>= CReal
y = Int -> Integer
s' (Int -> Int
digitsToBits Int
digits) forall a. Ord a => a -> a -> Bool
>= Integer
0 where (CR Int -> Integer
s') = CReal
xforall a. Num a => a -> a -> a
-CReal
y
  CReal
x > :: CReal -> CReal -> Bool
>  CReal
y = Int -> Integer
s' (Int -> Int
digitsToBits Int
digits) forall a. Ord a => a -> a -> Bool
>  Integer
0 where (CR Int -> Integer
s') = CReal
xforall a. Num a => a -> a -> a
-CReal
y
  max :: CReal -> CReal -> CReal
max (CR Int -> Integer
x') (CR Int -> Integer
y') = (Int -> Integer) -> CReal
CR (\Int
p -> forall a. Ord a => a -> a -> a
max (Int -> Integer
x' Int
p) (Int -> Integer
y' Int
p))
  min :: CReal -> CReal -> CReal
min (CR Int -> Integer
x') (CR Int -> Integer
y') = (Int -> Integer) -> CReal
CR (\Int
p -> forall a. Ord a => a -> a -> a
min (Int -> Integer
x' Int
p) (Int -> Integer
y' Int
p))

instance Num CReal where
  (CR Int -> Integer
x') + :: CReal -> CReal -> CReal
+ (CR Int -> Integer
y') = (Int -> Integer) -> CReal
CR (\Int
p -> Rational -> Integer
round_uk ((Int -> Integer
x' (Int
pforall a. Num a => a -> a -> a
+Int
2) forall a. Num a => a -> a -> a
+ Int -> Integer
y' (Int
pforall a. Num a => a -> a -> a
+Int
2)) forall a. Integral a => a -> a -> Ratio a
% Integer
4))
  (CR Int -> Integer
x') * :: CReal -> CReal -> CReal
* (CR Int -> Integer
y') = (Int -> Integer) -> CReal
CR (\Int
p -> Rational -> Integer
round_uk ((Int -> Integer
x' (Int
pforall a. Num a => a -> a -> a
+Int
sy)forall a. Num a => a -> a -> a
*Int -> Integer
y' (Int
pforall a. Num a => a -> a -> a
+Int
sx)) forall a. Integral a => a -> a -> Ratio a
% Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^(Int
pforall a. Num a => a -> a -> a
+Int
sxforall a. Num a => a -> a -> a
+Int
sy)))
                        where x0 :: Integer
x0 = forall a. Num a => a -> a
abs (Int -> Integer
x' Int
0)forall a. Num a => a -> a -> a
+Integer
2; y0 :: Integer
y0 = forall a. Num a => a -> a
abs (Int -> Integer
y' Int
0)forall a. Num a => a -> a -> a
+Integer
2
                              sx :: Int
sx = Integer -> Int -> Int
sizeinbase Integer
x0 Int
2forall a. Num a => a -> a -> a
+Int
3; sy :: Int
sy = Integer -> Int -> Int
sizeinbase Integer
y0 Int
2forall a. Num a => a -> a -> a
+Int
3
  negate :: CReal -> CReal
negate (CR Int -> Integer
x')    = (Int -> Integer) -> CReal
CR (\Int
p -> forall a. Num a => a -> a
negate (Int -> Integer
x' Int
p))
  abs :: CReal -> CReal
abs CReal
x             = forall a. Ord a => a -> a -> a
max CReal
x (forall a. Num a => a -> a
negate CReal
x)
  signum :: CReal -> CReal
signum (CR Int -> Integer
x')    = forall a. Num a => Integer -> a
fromInteger (forall a. Num a => a -> a
signum (Int -> Integer
x' (Int -> Int
digitsToBits Int
digits)))
  fromInteger :: Integer -> CReal
fromInteger Integer
n     = (Int -> Integer) -> CReal
CR (\Int
p -> Integer
nforall a. Num a => a -> a -> a
*Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
p)

instance Fractional CReal where
  recip :: CReal -> CReal
recip (CR Int -> Integer
x') = (Int -> Integer) -> CReal
CR (\Int
p -> let s :: Int
s = forall a. [a] -> a
head [Int
n | Int
n <- [Int
0..], Integer
3 forall a. Ord a => a -> a -> Bool
<= forall a. Num a => a -> a
abs (Int -> Integer
x' Int
n)]
                              in Rational -> Integer
round_uk (Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^(Int
2forall a. Num a => a -> a -> a
*Int
pforall a. Num a => a -> a -> a
+Int
2forall a. Num a => a -> a -> a
*Int
sforall a. Num a => a -> a -> a
+Int
2) forall a. Integral a => a -> a -> Ratio a
% (Int -> Integer
x' (Int
pforall a. Num a => a -> a -> a
+Int
2forall a. Num a => a -> a -> a
*Int
sforall a. Num a => a -> a -> a
+Int
2))))
  fromRational :: Rational -> CReal
fromRational Rational
x = forall a. Num a => Integer -> a
fromInteger (forall a. Ratio a -> a
numerator Rational
x) forall a. Fractional a => a -> a -> a
/ forall a. Num a => Integer -> a
fromInteger (forall a. Ratio a -> a
denominator Rational
x)

-- two useful scaling functions:


div2n :: CReal -> Int -> CReal
div2n :: CReal -> Int -> CReal
div2n (CR Int -> Integer
x') Int
n = (Int -> Integer) -> CReal
CR (\Int
p -> if Int
p forall a. Ord a => a -> a -> Bool
>= Int
n then Int -> Integer
x' (Int
pforall a. Num a => a -> a -> a
-Int
n) else Rational -> Integer
round_uk (Int -> Integer
x' Int
p forall a. Integral a => a -> a -> Ratio a
% Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
n))

mul2n :: CReal -> Int -> CReal
mul2n :: CReal -> Int -> CReal
mul2n (CR Int -> Integer
x') Int
n = (Int -> Integer) -> CReal
CR (\Int
p -> Int -> Integer
x' (Int
pforall a. Num a => a -> a -> a
+Int
n))

-- transcendental functions (mostly range reductions):


instance Floating CReal where
  pi :: CReal
pi = CReal
16 forall a. Num a => a -> a -> a
* forall a. Floating a => a -> a
atan (forall a. Fractional a => Rational -> a
fromRational (Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
5)) 
                forall a. Num a => a -> a -> a
- CReal
4 forall a. Num a => a -> a -> a
* forall a. Floating a => a -> a
atan (forall a. Fractional a => Rational -> a
fromRational (Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
239))
  sqrt :: CReal -> CReal
sqrt CReal
x  = (Int -> Integer) -> CReal
CR (\Int
p -> Integer -> Integer
floorsqrt (Int -> Integer
x' (Int
2forall a. Num a => a -> a -> a
*Int
p))) where (CR Int -> Integer
x') = CReal
x

  log :: CReal -> CReal
log CReal
x   = if Integer
t forall a. Ord a => a -> a -> Bool
< Integer
0 then forall a. HasCallStack => [Char] -> a
error [Char]
"log of negative number\n" else
            if Integer
t forall a. Ord a => a -> a -> Bool
< Integer
4 then - forall a. Floating a => a -> a
log (forall a. Fractional a => a -> a
recip CReal
x)                  else
            if Integer
t forall a. Ord a => a -> a -> Bool
< Integer
8 then CReal -> CReal
log_dr CReal
x                         else
            {- 7 < t -}   CReal -> CReal
log_dr (CReal -> Int -> CReal
div2n CReal
x Int
n) forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n forall a. Num a => a -> a -> a
* CReal
log2
            where (CR Int -> Integer
x') = CReal
x; t :: Integer
t = Int -> Integer
x' Int
2; n :: Int
n = Integer -> Int -> Int
sizeinbase Integer
t Int
2 forall a. Num a => a -> a -> a
- Int
3
  exp :: CReal -> CReal
exp CReal
x   = if Integer
n forall a. Ord a => a -> a -> Bool
< Integer
0 then CReal -> Int -> CReal
div2n (CReal -> CReal
exp_dr CReal
s) (forall a. Num a => Integer -> a
fromInteger (-Integer
n)) else
            if Integer
n forall a. Ord a => a -> a -> Bool
> Integer
0 then CReal -> Int -> CReal
mul2n (CReal -> CReal
exp_dr CReal
s) (forall a. Num a => Integer -> a
fromInteger Integer
n) else CReal -> CReal
exp_dr CReal
s
            where (CR Int -> Integer
u') = CReal
xforall a. Fractional a => a -> a -> a
/CReal
log2; n :: Integer
n = Int -> Integer
u' Int
0; s :: CReal
s = CReal
xforall a. Num a => a -> a -> a
-forall a. Num a => Integer -> a
fromInteger Integer
nforall a. Num a => a -> a -> a
*CReal
log2
  sin :: CReal -> CReal
sin CReal
x   = if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
0 then CReal -> CReal
sin_dr CReal
y                           else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
1 then CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
+ CReal -> CReal
sin_dr CReal
y)   else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
2 then CReal -> CReal
cos_dr CReal
y                           else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
3 then CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
- CReal -> CReal
sin_dr CReal
y)   else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
4 then - CReal -> CReal
sin_dr CReal
y                         else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
5 then - CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
+ CReal -> CReal
sin_dr CReal
y) else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
6 then - CReal -> CReal
cos_dr CReal
y                         else
            {- n == 7 -}   - CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
- CReal -> CReal
sin_dr CReal
y)
            where (CR Int -> Integer
z') = CReal
xforall a. Fractional a => a -> a -> a
/CReal
piBy4; s :: Integer
s = Rational -> Integer
round_uk (Int -> Integer
z' Int
2 forall a. Integral a => a -> a -> Ratio a
% Integer
4); n :: Integer
n = Integer
s forall a. Integral a => a -> a -> a
`mod` Integer
8
                  y :: CReal
y = CReal
x forall a. Num a => a -> a -> a
- CReal
piBy4 forall a. Num a => a -> a -> a
* forall a. Num a => Integer -> a
fromInteger Integer
s
  cos :: CReal -> CReal
cos CReal
x   = if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
0 then CReal -> CReal
cos_dr CReal
y                           else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
1 then CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
- CReal -> CReal
sin_dr CReal
y)   else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
2 then - CReal -> CReal
sin_dr CReal
y                           else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
3 then - CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
+ CReal -> CReal
sin_dr CReal
y)   else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
4 then - CReal -> CReal
cos_dr CReal
y                         else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
5 then - CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
- CReal -> CReal
sin_dr CReal
y) else
            if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
6 then CReal -> CReal
sin_dr CReal
y                         else
            {- n == 7 -}   CReal
sqrt1By2 forall a. Num a => a -> a -> a
* (CReal -> CReal
cos_dr CReal
y forall a. Num a => a -> a -> a
+ CReal -> CReal
sin_dr CReal
y)
            where (CR Int -> Integer
z') = CReal
xforall a. Fractional a => a -> a -> a
/CReal
piBy4; s :: Integer
s = Rational -> Integer
round_uk (Int -> Integer
z' Int
2 forall a. Integral a => a -> a -> Ratio a
% Integer
4); n :: Integer
n = Integer
s forall a. Integral a => a -> a -> a
`mod` Integer
8
                  y :: CReal
y = CReal
x forall a. Num a => a -> a -> a
- CReal
piBy4 forall a. Num a => a -> a -> a
* forall a. Num a => Integer -> a
fromInteger Integer
s
  atan :: CReal -> CReal
atan CReal
x  = if Integer
t forall a. Ord a => a -> a -> Bool
<  -Integer
5 then CReal -> CReal
atan_dr (forall a. Num a => a -> a
negate (forall a. Fractional a => a -> a
recip CReal
x)) forall a. Num a => a -> a -> a
- CReal
piBy2 else
            if Integer
t forall a. Eq a => a -> a -> Bool
== -Integer
4 then -CReal
piBy4 forall a. Num a => a -> a -> a
- CReal -> CReal
atan_dr (CReal
xp1forall a. Fractional a => a -> a -> a
/CReal
xm1)         else
            if Integer
t forall a. Ord a => a -> a -> Bool
<   Integer
4 then CReal -> CReal
atan_dr CReal
x                          else
            if Integer
t forall a. Eq a => a -> a -> Bool
==  Integer
4 then CReal
piBy4 forall a. Num a => a -> a -> a
+ CReal -> CReal
atan_dr (CReal
xm1forall a. Fractional a => a -> a -> a
/CReal
xp1)          else
            {- t >   4 -}   CReal
piBy2 forall a. Num a => a -> a -> a
- CReal -> CReal
atan_dr (forall a. Fractional a => a -> a
recip CReal
x)
            where (CR Int -> Integer
x') = CReal
x; t :: Integer
t = Int -> Integer
x' Int
2
                  xp1 :: CReal
xp1 = CReal
xforall a. Num a => a -> a -> a
+CReal
1; xm1 :: CReal
xm1 = CReal
xforall a. Num a => a -> a -> a
-CReal
1
  asin :: CReal -> CReal
asin CReal
x  = if Integer
x0 forall a. Ord a => a -> a -> Bool
>  Integer
0 then forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ CReal
2 forall a. Num a => a -> a -> a
- forall a. Floating a => a -> a
atan (CReal
sforall a. Fractional a => a -> a -> a
/CReal
x) else
            if Integer
x0 forall a. Eq a => a -> a -> Bool
== Integer
0 then forall a. Floating a => a -> a
atan (CReal
xforall a. Fractional a => a -> a -> a
/CReal
s)                      else
            {- x0 <  0 -}   - forall a. Floating a => a -> a
atan (CReal
sforall a. Fractional a => a -> a -> a
/CReal
x) forall a. Num a => a -> a -> a
- forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ CReal
2
            where (CR Int -> Integer
x') = CReal
x; x0 :: Integer
x0 = Int -> Integer
x' Int
0; s :: CReal
s = forall a. Floating a => a -> a
sqrt (CReal
1 forall a. Num a => a -> a -> a
- CReal
xforall a. Num a => a -> a -> a
*CReal
x)
  acos :: CReal -> CReal
acos CReal
x  = forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ CReal
2 forall a. Num a => a -> a -> a
- forall a. Floating a => a -> a
asin CReal
x
  sinh :: CReal -> CReal
sinh CReal
x  = (CReal
y forall a. Num a => a -> a -> a
- forall a. Fractional a => a -> a
recip CReal
y) forall a. Fractional a => a -> a -> a
/ CReal
2 where y :: CReal
y = forall a. Floating a => a -> a
exp CReal
x
  cosh :: CReal -> CReal
cosh CReal
x  = (CReal
y forall a. Num a => a -> a -> a
+ forall a. Fractional a => a -> a
recip CReal
y) forall a. Fractional a => a -> a -> a
/ CReal
2 where y :: CReal
y = forall a. Floating a => a -> a
exp CReal
x
  tanh :: CReal -> CReal
tanh CReal
x  = (CReal
y forall a. Num a => a -> a -> a
- CReal
y') forall a. Fractional a => a -> a -> a
/ (CReal
y forall a. Num a => a -> a -> a
+ CReal
y') where y :: CReal
y = forall a. Floating a => a -> a
exp CReal
x; y' :: CReal
y' = forall a. Fractional a => a -> a
recip CReal
y
  asinh :: CReal -> CReal
asinh CReal
x = forall a. Floating a => a -> a
log (CReal
x forall a. Num a => a -> a -> a
+ forall a. Floating a => a -> a
sqrt (CReal
xforall a. Num a => a -> a -> a
*CReal
x forall a. Num a => a -> a -> a
+ CReal
1))
  acosh :: CReal -> CReal
acosh CReal
x = forall a. Floating a => a -> a
log (CReal
x forall a. Num a => a -> a -> a
+ forall a. Floating a => a -> a
sqrt (CReal
xforall a. Num a => a -> a -> a
*CReal
x forall a. Num a => a -> a -> a
- CReal
1))
  atanh :: CReal -> CReal
atanh CReal
x = forall a. Floating a => a -> a
log ((CReal
1 forall a. Num a => a -> a -> a
+ CReal
x) forall a. Fractional a => a -> a -> a
/ (CReal
1 forall a. Num a => a -> a -> a
- CReal
x)) forall a. Fractional a => a -> a -> a
/ CReal
2


acc_seq :: (Rational -> Integer -> Rational) -> [Rational]
acc_seq :: (Rational -> Integer -> Rational) -> [Rational]
acc_seq Rational -> Integer -> Rational
f = forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl Rational -> Integer -> Rational
f (Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
1) [Integer
1..]

exp_dr :: CReal -> CReal
exp_dr :: CReal -> CReal
exp_dr = [Rational] -> (Int -> Int) -> CReal -> CReal
power_series ((Rational -> Integer -> Rational) -> [Rational]
acc_seq (\Rational
a Integer
n -> Rational
aforall a. Num a => a -> a -> a
*(Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
n))) forall a. a -> a
id

log_dr :: CReal -> CReal
log_dr :: CReal -> CReal
log_dr CReal
x = CReal
y forall a. Num a => a -> a -> a
* CReal -> CReal
log_drx CReal
y where y :: CReal
y = (CReal
x forall a. Num a => a -> a -> a
- CReal
1) forall a. Fractional a => a -> a -> a
/ CReal
x

log_drx :: CReal -> CReal
log_drx :: CReal -> CReal
log_drx = [Rational] -> (Int -> Int) -> CReal -> CReal
power_series [Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
n | Integer
n <- [Integer
1..]] (forall a. Num a => a -> a -> a
+Int
1)

sin_dr :: CReal -> CReal
sin_dr :: CReal -> CReal
sin_dr CReal
x = CReal
xforall a. Num a => a -> a -> a
*[Rational] -> (Int -> Int) -> CReal -> CReal
power_series ((Rational -> Integer -> Rational) -> [Rational]
acc_seq (\Rational
a Integer
n -> -Rational
aforall a. Num a => a -> a -> a
*(Integer
1 forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a. Num a => a -> a -> a
*Integer
nforall a. Num a => a -> a -> a
*(Integer
2forall a. Num a => a -> a -> a
*Integer
nforall a. Num a => a -> a -> a
+Integer
1))))) forall a. a -> a
id (CReal
xforall a. Num a => a -> a -> a
*CReal
x)

cos_dr :: CReal -> CReal
cos_dr :: CReal -> CReal
cos_dr CReal
x = [Rational] -> (Int -> Int) -> CReal -> CReal
power_series ((Rational -> Integer -> Rational) -> [Rational]
acc_seq (\Rational
a Integer
n -> -Rational
aforall a. Num a => a -> a -> a
*(Integer
1 forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a. Num a => a -> a -> a
*Integer
nforall a. Num a => a -> a -> a
*(Integer
2forall a. Num a => a -> a -> a
*Integer
nforall a. Num a => a -> a -> a
-Integer
1))))) forall a. a -> a
id (CReal
xforall a. Num a => a -> a -> a
*CReal
x)

atan_dr :: CReal -> CReal
atan_dr :: CReal -> CReal
atan_dr CReal
x = (CReal
xforall a. Fractional a => a -> a -> a
/CReal
y) forall a. Num a => a -> a -> a
* CReal -> CReal
atan_drx ((CReal
xforall a. Num a => a -> a -> a
*CReal
x)forall a. Fractional a => a -> a -> a
/CReal
y) where y :: CReal
y = CReal
xforall a. Num a => a -> a -> a
*CReal
xforall a. Num a => a -> a -> a
+CReal
1

atan_drx :: CReal -> CReal
atan_drx :: CReal -> CReal
atan_drx = [Rational] -> (Int -> Int) -> CReal -> CReal
power_series ((Rational -> Integer -> Rational) -> [Rational]
acc_seq (\Rational
a Integer
n -> Rational
aforall a. Num a => a -> a -> a
*((Integer
2forall a. Num a => a -> a -> a
*Integer
n) forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a. Num a => a -> a -> a
*Integer
nforall a. Num a => a -> a -> a
+Integer
1)))) (forall a. Num a => a -> a -> a
+Int
1)

-- power_series takes as arguments:

--   a (rational) list of the coefficients of the power series

--   a function from the desired accuracy to the number of terms needed

--   the argument x


power_series :: [Rational] -> (Int -> Int) -> CReal -> CReal
power_series :: [Rational] -> (Int -> Int) -> CReal -> CReal
power_series [Rational]
ps Int -> Int
terms (CR Int -> Integer
x')
  = (Int -> Integer) -> CReal
CR (\Int
p -> let t :: Int
t = Int -> Int
terms Int
p; l2t :: Int
l2t = Int
2forall a. Num a => a -> a -> a
*Integer -> Int -> Int
sizeinbase (forall a. Integral a => a -> Integer
toInteger Int
tforall a. Num a => a -> a -> a
+Integer
1) Int
2forall a. Num a => a -> a -> a
+Int
6; p' :: Int
p' = Int
p forall a. Num a => a -> a -> a
+ Int
l2t
                  xr :: Integer
xr = Int -> Integer
x' Int
p'; xn :: Integer
xn = Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
p'; g :: Integer -> Integer
g Integer
yn = Rational -> Integer
round_uk ((Integer
ynforall a. Num a => a -> a -> a
*Integer
xr) forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
p'))
               in Rational -> Integer
round_uk ([Integer] -> [Rational] -> Integer
accumulate (forall a. (a -> a) -> a -> [a]
iterate Integer -> Integer
g Integer
xn) (forall a. Int -> [a] -> [a]
take Int
t [Rational]
ps) forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
l2t)))
    where accumulate :: [Integer] -> [Rational] -> Integer
accumulate [Integer]
_      []     = Integer
0
          accumulate []     [Rational]
_      = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.power_series.accumulate"
          accumulate (Integer
x:[Integer]
xs) (Rational
c:[Rational]
cs) = let t :: Integer
t = Rational -> Integer
round_uk (Rational
cforall a. Num a => a -> a -> a
*(Integer
x forall a. Integral a => a -> a -> Ratio a
% Integer
1)) in
                                     if Integer
t forall a. Eq a => a -> a -> Bool
== Integer
0 then Integer
0 else Integer
t forall a. Num a => a -> a -> a
+ [Integer] -> [Rational] -> Integer
accumulate [Integer]
xs [Rational]
cs

-- Some useful constants:


piBy2 :: CReal
piBy2 :: CReal
piBy2 = CReal -> Int -> CReal
div2n forall a. Floating a => a
pi Int
1

piBy4 :: CReal
piBy4 :: CReal
piBy4 = CReal -> Int -> CReal
div2n forall a. Floating a => a
pi Int
2

log2 :: CReal
log2 :: CReal
log2 = CReal -> Int -> CReal
div2n (CReal -> CReal
log_drx (forall a. Fractional a => a -> a
recip CReal
2)) Int
1

sqrt1By2 :: CReal
sqrt1By2 :: CReal
sqrt1By2 = forall a. Floating a => a -> a
sqrt (forall a. Fractional a => a -> a
recip CReal
2)

instance Enum CReal where
  toEnum :: Int -> CReal
toEnum Int
i         = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
  fromEnum :: CReal -> Int
fromEnum CReal
_       = forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot fromEnum CReal"
  enumFrom :: CReal -> [CReal]
enumFrom         = forall a. (a -> a) -> a -> [a]
iterate (forall a. Num a => a -> a -> a
+ CReal
1)
  enumFromTo :: CReal -> CReal -> [CReal]
enumFromTo CReal
n CReal
e   = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Ord a => a -> a -> Bool
<= CReal
e) forall a b. (a -> b) -> a -> b
$ forall a. (a -> a) -> a -> [a]
iterate (forall a. Num a => a -> a -> a
+ CReal
1)CReal
n
  enumFromThen :: CReal -> CReal -> [CReal]
enumFromThen CReal
n CReal
m = forall a. (a -> a) -> a -> [a]
iterate (forall a. Num a => a -> a -> a
+(CReal
mforall a. Num a => a -> a -> a
-CReal
n)) CReal
n
  enumFromThenTo :: CReal -> CReal -> CReal -> [CReal]
enumFromThenTo CReal
n CReal
m CReal
e = if CReal
m forall a. Ord a => a -> a -> Bool
>= CReal
n then forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Ord a => a -> a -> Bool
<= CReal
e) forall a b. (a -> b) -> a -> b
$ forall a. (a -> a) -> a -> [a]
iterate (forall a. Num a => a -> a -> a
+(CReal
mforall a. Num a => a -> a -> a
-CReal
n)) CReal
n
                          else forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Ord a => a -> a -> Bool
>= CReal
e) forall a b. (a -> b) -> a -> b
$ forall a. (a -> a) -> a -> [a]
iterate (forall a. Num a => a -> a -> a
+(CReal
mforall a. Num a => a -> a -> a
-CReal
n)) CReal
n

instance Real CReal where
 -- toRational x@(CR x') = x' n % 2^n where n = digitsToBits digits

  toRational :: CReal -> Rational
toRational CReal
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.toRational"
instance RealFrac CReal where
  properFraction :: forall b. Integral b => CReal -> (b, CReal)
properFraction x :: CReal
x@(CR Int -> Integer
x') = (forall a. Num a => Integer -> a
fromInteger Integer
n, CReal
x forall a. Num a => a -> a -> a
- forall a. Num a => Integer -> a
fromInteger Integer
n) where n :: Integer
n = Int -> Integer
x' Int
0

instance RealFloat CReal where
  floatRadix :: CReal -> Integer
floatRadix CReal
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.floatRadix"
  floatDigits :: CReal -> Int
floatDigits CReal
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.floatDigits"
  floatRange :: CReal -> (Int, Int)
floatRange CReal
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.floatRange"
  decodeFloat :: CReal -> (Integer, Int)
decodeFloat CReal
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.decodeFloat"
  encodeFloat :: Integer -> Int -> CReal
encodeFloat Integer
_ Int
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"CReal.encodeFloat"
  exponent :: CReal -> Int
exponent CReal
_ = Int
0
  scaleFloat :: Int -> CReal -> CReal
scaleFloat Int
0 CReal
x = CReal
x
  significand :: CReal -> CReal
significand CReal
x = CReal
x
  isNaN :: CReal -> Bool
isNaN CReal
_ = Bool
False
  isInfinite :: CReal -> Bool
isInfinite CReal
_ = Bool
False
  isDenormalized :: CReal -> Bool
isDenormalized CReal
_ = Bool
False
  isNegativeZero :: CReal -> Bool
isNegativeZero CReal
_ = Bool
False
  isIEEE :: CReal -> Bool
isIEEE CReal
_ = Bool
False

-- printing and reading the reals:


-- |The 'showCReal' function connverts a 'CReal' to a 'String'.

showCReal :: Int                -- ^ The number of decimals

          -> CReal              -- ^ The real number

          -> String             -- ^ The resulting string

showCReal :: Int -> CReal -> [Char]
showCReal Int
d (CR Int -> Integer
x')
  = (if Bool
s then [Char]
"-" else [Char]
"") forall a. [a] -> [a] -> [a]
++ [Char]
zs forall a. [a] -> [a] -> [a]
++ (if Int
d forall a. Eq a => a -> a -> Bool
/= Int
0 then Char
'.'forall a. a -> [a] -> [a]
:[Char]
fs' else [Char]
"")
    where b :: Int
b  = Int -> Int
digitsToBits Int
d
          n :: Integer
n  = Int -> Integer
x' Int
b
          ds :: [Char]
ds = forall a. Show a => a -> [Char]
show (Rational -> Integer
round_uk ((Integer
nforall a. Num a => a -> a -> a
*Integer
10forall a b. (Num a, Integral b) => a -> b -> a
^Int
d) forall a. Integral a => a -> a -> Ratio a
% Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
b))
          (Bool
s,[Char]
ds') = let sgn :: Bool
sgn = forall a. [a] -> a
head [Char]
ds forall a. Eq a => a -> a -> Bool
== Char
'-' in (Bool
sgn, if Bool
sgn then forall a. [a] -> [a]
tail [Char]
ds else [Char]
ds)
          ds'' :: [Char]
ds'' = forall a. Int -> [a] -> [a]
take (forall a. Ord a => a -> a -> a
max (Int
dforall a. Num a => a -> a -> a
+Int
1forall a. Num a => a -> a -> a
-forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
ds') Int
0) (forall a. a -> [a]
repeat Char
'0') forall a. [a] -> [a] -> [a]
++ [Char]
ds'
          ([Char]
zs,[Char]
fs) = forall a. Int -> [a] -> ([a], [a])
splitAt (forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
ds'' forall a. Num a => a -> a -> a
-Int
d) [Char]
ds''
          fs' :: [Char]
fs' = case forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
== Char
'0') forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [Char]
fs of
                [Char]
"" -> [Char]
"0"
                [Char]
xs -> [Char]
xs

digitsToBits :: Int -> Int
digitsToBits :: Int -> Int
digitsToBits Int
d = forall a b. (RealFrac a, Integral b) => a -> b
ceiling (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
d forall a. Num a => a -> a -> a
* (forall a. Floating a => a -> a -> a
logBase Double
2.0 Double
10.0 :: Double)) forall a. Num a => a -> a -> a
+ Int
4

digits :: Int
digits :: Int
digits = Int
40

instance Read CReal where
  readsPrec :: Int -> ReadS CReal
readsPrec Int
_p = forall a. Real a => ReadS a -> ReadS a
readSigned forall a. RealFrac a => ReadS a
readFloat

instance Show CReal where
  showsPrec :: Int -> CReal -> ShowS
showsPrec Int
p CReal
x = let xs :: [Char]
xs = Int -> CReal -> [Char]
showCReal Int
digits CReal
x in
                  if forall a. [a] -> a
head [Char]
xs forall a. Eq a => a -> a -> Bool
== Char
'-' then Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
6) ([Char] -> ShowS
showString [Char]
xs)
                                    else [Char] -> ShowS
showString [Char]
xs

-- GMP functions not provided by Haskell


sizeinbase :: Integer -> Int -> Int
sizeinbase :: Integer -> Int -> Int
sizeinbase Integer
i Int
b = forall a. Num a => Integer -> a
f (forall a. Num a => a -> a
abs Integer
i)
                 where f :: Integer -> a
f Integer
n = if Integer
n forall a. Ord a => a -> a -> Bool
<= Integer
1 then a
1 else a
1 forall a. Num a => a -> a -> a
+ Integer -> a
f (Integer
n forall a. Integral a => a -> a -> a
`div` forall a. Integral a => a -> Integer
toInteger Int
b)

floorsqrt :: Integer -> Integer
floorsqrt :: Integer -> Integer
floorsqrt Integer
x = forall a. (a -> Bool) -> (a -> a) -> a -> a
until Integer -> Bool
satisfy forall {b}. Integral b => Integer -> b
improve Integer
x
              where improve :: Integer -> b
improve Integer
y = forall a b. (RealFrac a, Integral b) => a -> b
floor ((Integer
yforall a. Num a => a -> a -> a
*Integer
yforall a. Num a => a -> a -> a
+Integer
x) forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a. Num a => a -> a -> a
*Integer
y))
                    satisfy :: Integer -> Bool
satisfy Integer
y = Integer
yforall a. Num a => a -> a -> a
*Integer
y forall a. Ord a => a -> a -> Bool
<= Integer
x Bool -> Bool -> Bool
&& Integer
x forall a. Ord a => a -> a -> Bool
<= (Integer
yforall a. Num a => a -> a -> a
+Integer
1)forall a. Num a => a -> a -> a
*(Integer
yforall a. Num a => a -> a -> a
+Integer
1)

round_uk :: Rational -> Integer
round_uk :: Rational -> Integer
round_uk Rational
x = forall a b. (RealFrac a, Integral b) => a -> b
floor (Rational
xforall a. Num a => a -> a -> a
+Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
2)