module Data.Number.Flint.Arb.RealField (
  RF(..)
, RF'(..)
, Special (..)
, fromDouble
, toDouble
) where

import GHC.TypeLits
import Data.Proxy

import GHC.Read 
import qualified Text.Read.Lex as Lex
import Text.ParserCombinators.ReadPrec hiding (prec)

import Data.Ratio

import System.IO.Unsafe
import Control.Monad

import Foreign.C.String
import Foreign.C.Types
import Foreign.ForeignPtr
import Foreign.Ptr ( Ptr, FunPtr )
import Foreign.Storable
import Foreign.Marshal (free)

import Data.Number.Flint.Fmpz
import Data.Number.Flint.Fmpz.Instances
import Data.Number.Flint.Arb
import Data.Number.Flint.Arb.Arf
import Data.Number.Flint.Arb.Mag
import Data.Number.Flint.Arb.Types
import Data.Number.Flint.Arb.Hypgeom
import Data.Number.Flint.Support.D.Interval

newtype RF (n :: Nat) = RF Arb

instance forall n. KnownNat n => Eq (RF n) where
  {-# INLINE (==) #-}
  == :: RF n -> RF n -> Bool
(==) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_eq
  {-# INLINE (/=) #-}
  /= :: RF n -> RF n -> Bool
(/=) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_ne

instance forall n. KnownNat n => Ord (RF n) where
  {-# INLINE (<) #-}
  < :: RF n -> RF n -> Bool
(<) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_lt
  {-# INLINE (<=) #-}
  <= :: RF n -> RF n -> Bool
(<=) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_le
  {-# INLINE (>) #-}
  > :: RF n -> RF n -> Bool
(>) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_gt
  {-# INLINE (>=) #-}
  >= :: RF n -> RF n -> Bool
(>=) = forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
arb_ge
  {-# INLINE max #-}
  max :: RF n -> RF n -> RF n
max = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_max
  {-# INLINE min #-}
  min :: RF n -> RF n -> RF n
min = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_min
  
instance forall n. KnownNat n => Num (RF n) where
  {-# INLINE (+) #-}
  + :: RF n -> RF n -> RF n
(+) = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_add
  {-# INLINE (-) #-}
  (-) = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_sub
  {-# INLINE (*) #-}
  * :: RF n -> RF n -> RF n
(*) = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_mul
  {-# INLINE negate #-}
  negate :: RF n -> RF n
negate = forall (n :: Nat). KnownNat n => Function -> RF n -> RF n
lift1 Function
arb_neg
  {-# INLINE abs #-}
  abs :: RF n -> RF n
abs = forall (n :: Nat). KnownNat n => Function -> RF n -> RF n
lift1 Function
arb_abs
  {-# INLINE fromInteger #-}
  fromInteger :: Integer -> RF n
fromInteger Integer
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let prec :: CLong
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
    Arb
result <- IO Arb
newArb
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
result forall a b. (a -> b) -> a -> b
$ \Ptr CArb
result -> do
      forall a. String -> (CString -> IO a) -> IO a
withCString (forall a. Show a => a -> String
show Integer
x) forall a b. (a -> b) -> a -> b
$ \CString
s -> do
        CInt
flag <- Ptr CArb -> CString -> CLong -> IO CInt
arb_set_str Ptr CArb
result CString
s CLong
prec
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CInt
flag forall a. Eq a => a -> a -> Bool
/= CInt
0) forall a b. (a -> b) -> a -> b
$
          forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"Could not create RF " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show CLong
prec forall a. [a] -> [a] -> [a]
++ String
" from " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Integer
x
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Arb -> RF n
RF Arb
result)
  {-# INLINE signum #-}
  signum :: RF n -> RF n
signum = forall (n :: Nat). KnownNat n => Function -> RF n -> RF n
lift1 Function
arb_sgn
  
instance forall n. KnownNat n => Fractional (RF n) where
  {-# INLINE (/) #-}
  / :: RF n -> RF n -> RF n
(/) = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_div
  fromRational :: Rational -> RF n
fromRational Rational
x = RF n
p forall a. Fractional a => a -> a -> a
/ RF n
q where
    p :: RF n
p = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Ratio a -> a
numerator Rational
x) :: RF n
    q :: RF n
q = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Ratio a -> a
denominator Rational
x) :: RF n

instance forall n. KnownNat n => RealFloat (RF n) where
  isNaN :: RF n -> Bool
isNaN = Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> IO CInt) -> RF n -> Bool
liftProp Ptr CArb -> IO CInt
arb_is_finite
  isInfinite :: RF n -> Bool
isInfinite = Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> IO CInt) -> RF n -> Bool
liftProp Ptr CArb -> IO CInt
arb_is_finite
  floatRadix :: RF n -> Integer
floatRadix RF n
_ = Integer
2
  floatDigits :: RF n -> Int
floatDigits RF n
_ = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
  floatRange :: RF n -> (Int, Int)
floatRange RF n
_ = (forall a. Bounded a => a
minBound :: Int, forall a. Bounded a => a
maxBound :: Int)
  decodeFloat :: RF n -> (Integer, Int)
decodeFloat (RF Arb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Fmpz
man <- IO Fmpz
newFmpz
    Fmpz
exp <- IO Fmpz
newFmpz 
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
a -> do
      forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
man forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
man -> do
        forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
exp forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
exp -> do
          Ptr CFmpz -> Ptr CFmpz -> Ptr CArf -> IO ()
arf_get_fmpz_2exp Ptr CFmpz
man Ptr CFmpz
exp (Ptr CArb -> Ptr CArf
arb_midref Ptr CArb
a)
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Integral a => a -> Integer
toInteger Fmpz
man, forall a b. (Integral a, Num b) => a -> b
fromIntegral Fmpz
exp)
  encodeFloat :: Integer -> Int -> RF n
encodeFloat Integer
man Int
exp = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let prec :: CLong
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
        m :: Fmpz
m = forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
man :: Fmpz
        e :: Fmpz
e = forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
exp :: Fmpz
    Arb
res <- IO Arb
newArb
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
res forall a b. (a -> b) -> a -> b
$ \Ptr CArb
res -> do 
      forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
m forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
m -> do
        forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
e forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
e -> do
          forall {a}. (Ptr CArf -> IO a) -> IO (Arf, a)
withNewArf forall a b. (a -> b) -> a -> b
$ \ Ptr CArf
arf -> do
            Ptr CArf -> Ptr CFmpz -> Ptr CFmpz -> CLong -> ArfRnd -> IO CInt
arf_set_round_fmpz_2exp Ptr CArf
arf Ptr CFmpz
m Ptr CFmpz
e CLong
prec ArfRnd
arf_rnd_near
            Ptr CArb -> Ptr CArf -> IO ()
arb_set_arf Ptr CArb
res Ptr CArf
arf
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Arb -> RF n
RF Arb
res
  isDenormalized :: RF n -> Bool
isDenormalized = forall a. HasCallStack => String -> a
error String
"isDenormalized: not defined"
  isNegativeZero :: RF n -> Bool
isNegativeZero = forall a. HasCallStack => String -> a
error String
"isNegativeZero: not defined"
  isIEEE :: RF n -> Bool
isIEEE RF n
_ = Bool
False
  atan2 :: RF n -> RF n -> RF n
atan2 = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_atan2

instance forall n. KnownNat n => Real (RF n) where
  toRational :: RF n -> Rational
toRational RF n
x =
    case forall a. RealFloat a => a -> (Integer, Int)
decodeFloat RF n
x of
      (Integer
m, Int
n) -> if Int
n forall a. Ord a => a -> a -> Bool
>= Int
0 then (Integer
mforall a. Num a => a -> a -> a
*Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^Int
n)forall a. Integral a => a -> a -> Ratio a
%Integer
1 else Integer
m forall a. Integral a => a -> a -> Ratio a
% (Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^(-Int
n))

instance forall n. KnownNat n => RealFrac (RF n) where
  properFraction :: forall b. Integral b => RF n -> (b, RF n)
properFraction RF n
x
    = case (forall a. RealFloat a => a -> (Integer, Int)
decodeFloat RF n
x) of { (Integer
m,Int
n) ->
      if Int
n forall a. Ord a => a -> a -> Bool
>= Int
0 then
          (forall a. Num a => Integer -> a
fromInteger Integer
m forall a. Num a => a -> a -> a
* b
2 forall a b. (Num a, Integral b) => a -> b -> a
^ Int
n, RF n
0.0)
      else
          case (forall a. Integral a => a -> a -> (a, a)
quotRem Integer
m (Integer
2forall a b. (Num a, Integral b) => a -> b -> a
^(forall a. Num a => a -> a
negate Int
n))) of { (Integer
w,Integer
r) ->
          (forall a. Num a => Integer -> a
fromInteger Integer
w, forall a. RealFloat a => Integer -> Int -> a
encodeFloat Integer
r Int
n)
          }
      }

instance forall n. KnownNat n => Floating (RF n) where
  pi :: RF n
pi = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_pi
  exp :: RF n -> RF n
exp = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_exp
  log :: RF n -> RF n
log = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_log
  sqrt :: RF n -> RF n
sqrt = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_sqrt
  sin :: RF n -> RF n
sin = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_sin
  cos :: RF n -> RF n
cos = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_cos
  tan :: RF n -> RF n
tan = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_tan
  asin :: RF n -> RF n
asin = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_asin
  acos :: RF n -> RF n
acos = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_acos
  atan :: RF n -> RF n
atan = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_atan
  sinh :: RF n -> RF n
sinh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_sinh
  cosh :: RF n -> RF n
cosh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_cosh
  tanh :: RF n -> RF n
tanh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_tanh
  asinh :: RF n -> RF n
asinh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_asinh
  acosh :: RF n -> RF n
acosh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_acosh
  atanh :: RF n -> RF n
atanh = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_atanh
  
instance forall n. KnownNat n => Show (RF n) where
  show :: RF n -> String
show (RF Arb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let prec :: Integer
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
        digits :: Integer
digits = forall a b. (RealFrac a, Integral b) => a -> b
floor (forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
prec forall a. Num a => a -> a -> a
* forall a. Floating a => a -> a -> a
logBase Double
10 Double
2)
    (Arb
_, CString
cstr) <- forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
p ->
      Ptr CArb -> CLong -> ArbStrOption -> IO CString
arb_get_str Ptr CArb
p (forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
digits) ArbStrOption
arb_str_no_radius
    String
str <- CString -> IO String
peekCString CString
cstr
    forall (m :: * -> *) a. Monad m => a -> m a
return String
str

instance forall n. KnownNat n => Read (RF n) where
  readPrec :: ReadPrec (RF n)
readPrec     = forall a. Num a => (Lexeme -> ReadPrec a) -> ReadPrec a
readNumber forall a. RealFloat a => Lexeme -> ReadPrec a
convertFrac
  readListPrec :: ReadPrec [RF n]
readListPrec = forall a. Read a => ReadPrec [a]
readListPrecDefault
  readList :: ReadS [RF n]
readList     = forall a. Read a => ReadS [a]
readListDefault

convertFrac :: RealFloat a => Lex.Lexeme -> ReadPrec a
convertFrac :: forall a. RealFloat a => Lexeme -> ReadPrec a
convertFrac (Lex.Ident String
"NaN")      = forall (m :: * -> *) a. Monad m => a -> m a
return (a
0 forall a. Fractional a => a -> a -> a
/ a
0)
convertFrac (Lex.Ident String
"Infinity") = forall (m :: * -> *) a. Monad m => a -> m a
return (a
1 forall a. Fractional a => a -> a -> a
/ a
0)
convertFrac (Lex.Number Number
n) = let resRange :: (Int, Int)
resRange = forall a. RealFloat a => a -> (Int, Int)
floatRange (forall a. HasCallStack => a
undefined :: a)
                           in case (Int, Int) -> Number -> Maybe Rational
Lex.numberToRangedRational (Int, Int)
resRange Number
n of
                              Maybe Rational
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (a
1 forall a. Fractional a => a -> a -> a
/ a
0)
                              Just Rational
rat -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Fractional a => Rational -> a
fromRational Rational
rat
convertFrac Lexeme
_            = forall a. ReadPrec a
pfail

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

instance forall n. KnownNat n => Special (RF n) where
  gamma :: RF n -> RF n
gamma = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_gamma
  digamma :: RF n -> RF n
digamma = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_digamma
  lgamma :: RF n -> RF n
lgamma = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_hypgeom_lgamma
  zeta :: RF n -> RF n
zeta = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_zeta
  erf :: RF n -> RF n
erf = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_hypgeom_erf
  airy :: RF n -> (RF n, RF n, RF n, RF n)
airy (RF Arb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let prec :: CLong
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
    Arb
ai <- IO Arb
newArb
    Arb
ai' <- IO Arb
newArb
    Arb
bi <- IO Arb
newArb
    Arb
bi' <- IO Arb
newArb
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> 
      forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
ai forall a b. (a -> b) -> a -> b
$ \Ptr CArb
ai -> 
        forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
ai' forall a b. (a -> b) -> a -> b
$ \Ptr CArb
ai' ->
          forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
bi forall a b. (a -> b) -> a -> b
$ \Ptr CArb
bi ->
            forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
bi' forall a b. (a -> b) -> a -> b
$ \Ptr CArb
bi' ->
              Ptr CArb -> Ptr CArb -> Binary
arb_hypgeom_airy Ptr CArb
ai Ptr CArb
ai' Ptr CArb
bi Ptr CArb
bi' Ptr CArb
x CLong
prec
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (forall (n :: Nat). Arb -> RF n
RF Arb
ai, forall (n :: Nat). Arb -> RF n
RF Arb
ai', forall (n :: Nat). Arb -> RF n
RF Arb
bi, forall (n :: Nat). Arb -> RF n
RF Arb
bi')
  airyZeros :: Fmpz -> (RF n, RF n, RF n, RF n)
airyZeros Fmpz
k = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let prec :: CLong
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
    Arb
ai <- IO Arb
newArb
    Arb
ai' <- IO Arb
newArb
    Arb
bi <- IO Arb
newArb
    Arb
bi' <- IO Arb
newArb
    forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
k forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
k -> 
      forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
ai forall a b. (a -> b) -> a -> b
$ \Ptr CArb
ai -> 
        forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
ai' forall a b. (a -> b) -> a -> b
$ \Ptr CArb
ai' ->
          forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
bi forall a b. (a -> b) -> a -> b
$ \Ptr CArb
bi ->
            forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
bi' forall a b. (a -> b) -> a -> b
$ \Ptr CArb
bi' ->
              Ptr CArb
-> Ptr CArb -> Ptr CArb -> Ptr CArb -> Ptr CFmpz -> CLong -> IO ()
arb_hypgeom_airy_zero Ptr CArb
ai Ptr CArb
ai' Ptr CArb
bi Ptr CArb
bi' Ptr CFmpz
k CLong
prec
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (forall (n :: Nat). Arb -> RF n
RF Arb
ai, forall (n :: Nat). Arb -> RF n
RF Arb
ai', forall (n :: Nat). Arb -> RF n
RF Arb
bi, forall (n :: Nat). Arb -> RF n
RF Arb
bi')
  besselJ :: RF n -> RF n -> RF n
besselJ = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_hypgeom_bessel_j
  besselY :: RF n -> RF n -> RF n
besselY = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_hypgeom_bessel_y
  besselI :: RF n -> RF n -> RF n
besselI = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_hypgeom_bessel_i
  besselK :: RF n -> RF n -> RF n
besselK = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_hypgeom_bessel_k
  modj :: RF n -> RF n
modj = forall a. HasCallStack => a
undefined
  modjq :: RF n -> RF n
modjq = forall a. HasCallStack => a
undefined
  modeta :: RF n -> RF n
modeta = forall a. HasCallStack => a
undefined
  modetaq :: RF n -> RF n
modetaq = forall a. HasCallStack => a
undefined
  modlambda :: RF n -> RF n
modlambda = forall a. HasCallStack => a
undefined
  modlambdaq :: RF n -> RF n
modlambdaq = forall a. HasCallStack => a
undefined
  ellipp :: RF n -> RF n -> RF n
ellipp = forall a. HasCallStack => a
undefined
  ellipzeta :: RF n -> RF n -> RF n
ellipzeta = forall a. HasCallStack => a
undefined
  ellipsigma :: RF n -> RF n -> RF n
ellipsigma = forall a. HasCallStack => a
undefined
  barnesg :: RF n -> RF n
barnesg = forall a. HasCallStack => a
undefined
  agm :: RF n -> RF n -> RF n
agm = forall a. HasCallStack => a
undefined
  fresnels :: RF n -> RF n
fresnels = forall a. HasCallStack => a
undefined
  fresnelc :: RF n -> RF n
fresnelc = forall a. HasCallStack => a
undefined
  
class RF' a where
  euler :: a
  glaisher :: a
  catalan :: a
  khinchin :: a
  polylog :: a -> a -> a
  midPoint :: a -> a
  
instance forall n. KnownNat n => RF' (RF n) where
  euler :: RF n
euler = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_euler
  glaisher :: RF n
glaisher = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_glaisher
  catalan :: RF n
catalan = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_catalan
  khinchin :: RF n
khinchin = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_khinchin
  polylog :: RF n -> RF n -> RF n
polylog = forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
arb_polylog
  midPoint :: RF n -> RF n
midPoint = forall (n :: Nat). KnownNat n => Function -> RF n -> RF n
lift1 Function
arb_get_mid_arb

fromDouble ::  forall n. KnownNat n => Double -> RF n
fromDouble :: forall (n :: Nat). KnownNat n => Double -> RF n
fromDouble Double
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  Arb
res <- IO Arb
newArb
  forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
res forall a b. (a -> b) -> a -> b
$ \Ptr CArb
res -> Ptr CArb -> CDouble -> IO ()
arb_set_d Ptr CArb
res (forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Arb -> RF n
RF Arb
res
  
toDouble :: forall n. KnownNat n => RF n -> Double
toDouble :: forall (n :: Nat). KnownNat n => RF n -> Double
toDouble RF n
x = forall a. Fractional a => Rational -> a
fromRational forall a b. (a -> b) -> a -> b
$ forall a. Real a => a -> Rational
toRational RF n
x
    
-- lifting -------------------------------------------------------------

type Binary = Ptr CArb -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
type Cmp = Ptr CArb -> Ptr CArb -> IO CInt
type Function = Ptr CArb -> Ptr CArb -> IO ()

lift2 :: forall n. KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 :: forall (n :: Nat). KnownNat n => Binary -> RF n -> RF n -> RF n
lift2 Binary
f (RF Arb
a) (RF Arb
b) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  let prec :: Int64
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
  Arb
c <- IO Arb
newArb
  forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
a forall a b. (a -> b) -> a -> b
$ \Ptr CArb
a ->
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
b forall a b. (a -> b) -> a -> b
$ \Ptr CArb
b ->
      forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
c forall a b. (a -> b) -> a -> b
$ \Ptr CArb
c ->
        Binary
f Ptr CArb
c Ptr CArb
a Ptr CArb
b (Int64 -> CLong
CLong Int64
prec)
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Arb -> RF n
RF Arb
c)

lift1 :: forall n. KnownNat n => Function -> RF n -> RF n
lift1 :: forall (n :: Nat). KnownNat n => Function -> RF n -> RF n
lift1 Function
f (RF Arb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  Arb
y <- IO Arb
newArb
  forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
y forall a b. (a -> b) -> a -> b
$ \Ptr CArb
y -> Function
f Ptr CArb
y Ptr CArb
x
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Arb -> RF n
RF Arb
y)
  
lift0 :: (Ptr CArb -> p -> IO b) -> p -> RF n
lift0 Ptr CArb -> p -> IO b
f p
x = forall (n :: Nat). Arb -> RF n
RF forall a b. (a -> b) -> a -> b
$ forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb (Ptr CArb -> p -> IO b
`f` p
x)
  
liftF1 :: forall n. KnownNat n =>
  (Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 :: forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> Ptr CArb -> CLong -> IO ()) -> RF n -> RF n
liftF1 Ptr CArb -> Ptr CArb -> CLong -> IO ()
f (RF Arb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  let prec :: Int64
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
  Arb
y <- IO Arb
newArb
  forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
y forall a b. (a -> b) -> a -> b
$ \Ptr CArb
y -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
f Ptr CArb
y Ptr CArb
x (Int64 -> CLong
CLong Int64
prec)
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Arb -> RF n
RF Arb
y)

liftCmp :: forall n. KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp :: forall (n :: Nat). KnownNat n => Cmp -> RF n -> RF n -> Bool
liftCmp Cmp
f (RF Arb
x) (RF Arb
y) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (Arb
_, (Arb
_, CInt
cmp)) <- forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
y forall a b. (a -> b) -> a -> b
$ \Ptr CArb
y -> Cmp
f Ptr CArb
x Ptr CArb
y
  forall (m :: * -> *) a. Monad m => a -> m a
return (CInt
cmp forall a. Eq a => a -> a -> Bool
== CInt
1)

liftProp :: forall n. KnownNat n => (Ptr CArb -> IO CInt) -> RF n -> Bool
liftProp :: forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> IO CInt) -> RF n -> Bool
liftProp Ptr CArb -> IO CInt
f (RF Arb
x)  = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (Arb
_, CInt
prop) <- forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
x forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> Ptr CArb -> IO CInt
f Ptr CArb
x
  forall (m :: * -> *) a. Monad m => a -> m a
return (CInt
prop forall a. Eq a => a -> a -> Bool
== CInt
1)

liftConstant :: forall n. KnownNat n => (Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant :: forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> RF n
liftConstant Ptr CArb -> CLong -> IO ()
f = forall (n :: Nat). Arb -> RF n
RF forall a b. (a -> b) -> a -> b
$ forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  let prec :: Int64
prec = forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
  forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb (Ptr CArb -> CLong -> IO ()
`f` Int64 -> CLong
CLong Int64
prec)

class Special a where
  gamma :: a -> a
  digamma :: a -> a
  lgamma :: a -> a
  zeta :: a -> a
  erf :: a -> a
  airy :: a -> (a, a, a, a)
  airyZeros :: Fmpz -> (a, a, a, a)
  besselJ :: a -> a -> a
  besselY :: a -> a -> a
  besselI :: a -> a -> a
  besselK :: a -> a -> a
  modj :: a -> a
  modjq :: a -> a
  modeta :: a -> a
  modetaq :: a -> a
  modlambda :: a -> a
  modlambdaq :: a -> a
  ellipp :: a -> a -> a
  ellipzeta :: a -> a -> a
  ellipsigma :: a -> a -> a
  barnesg :: a -> a
  agm :: a -> a -> a
  fresnels :: a -> a
  fresnelc :: a -> a