module Data.Number.Flint.Acb.ComplexField (
  CF(..)
, RF'(..)
, Special (..)
, realPart
, imagPart
-- * Polar form
, mkPolar
, cis
, polar
, magnitude
, phase
-- * Conjugate
, conjugate
) where

import GHC.TypeLits
import Data.Proxy
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, castPtr )
import Foreign.Storable
import Foreign.Marshal ( free )
import Foreign.Marshal.Array ( advancePtr )

import Data.Number.Flint.Fmpz
import Data.Number.Flint.Fmpz.Instances
import Data.Number.Flint.Arb
import Data.Number.Flint.Arb.RealField

import Data.Number.Flint.Arb.Types
import Data.Number.Flint.Acb
import Data.Number.Flint.Acb.Acf
import Data.Number.Flint.Acb.Types
import Data.Number.Flint.Acb.Hypgeom
import Data.Number.Flint.Acb.Modular
import Data.Number.Flint.Acb.Elliptic

import Data.Number.Flint.Support.D.Interval

newtype CF (n :: Nat) = CF Acb

realPart :: forall n. KnownNat n => (CF n) -> (RF n)
realPart :: forall (n :: Nat). KnownNat n => CF n -> RF n
realPart (CF Acb
z) = 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 -> do 
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
z forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
z -> do
      Ptr CArb -> Ptr CAcb -> IO ()
acb_get_real Ptr CArb
res Ptr CAcb
z
  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

imagPart :: forall n. KnownNat n => (CF n) -> (RF n)
imagPart :: forall (n :: Nat). KnownNat n => CF n -> RF n
imagPart (CF Acb
z) = 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 -> do
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
z forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
z -> do
      Ptr CArb -> Ptr CAcb -> IO ()
acb_get_imag Ptr CArb
res Ptr CAcb
z
  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

mkPolar :: forall n. KnownNat n => (RF n) -> (RF n) -> (CF n)
mkPolar :: forall (n :: Nat). KnownNat n => RF n -> RF n -> CF n
mkPolar (RF Arb
r) (RF Arb
theta) = 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)
  Acb
res <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
res forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
res -> do 
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
r forall a b. (a -> b) -> a -> b
$ \Ptr CArb
r -> do
      forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
theta forall a b. (a -> b) -> a -> b
$ \Ptr CArb
theta -> do
        forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> do
          forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb forall a b. (a -> b) -> a -> b
$ \Ptr CArb
y -> do
            Ptr CArb -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_sin_cos Ptr CArb
y Ptr CArb
x Ptr CArb
theta CLong
prec
            Ptr CArb -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_mul Ptr CArb
x Ptr CArb
x Ptr CArb
r CLong
prec
            Ptr CArb -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_mul Ptr CArb
y Ptr CArb
y Ptr CArb
r CLong
prec
            Ptr CAcb -> Ptr CArb -> Ptr CArb -> IO ()
acb_set_arb_arb Ptr CAcb
res Ptr CArb
x Ptr CArb
y
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Acb -> CF n
CF Acb
res

cis :: forall n. KnownNat n => (RF n) -> (CF n)
cis :: forall (n :: Nat). KnownNat n => RF n -> CF n
cis (RF Arb
theta) = 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)
  Acb
res <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
res forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
res -> do 
    forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
theta forall a b. (a -> b) -> a -> b
$ \Ptr CArb
theta -> do
      forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb forall a b. (a -> b) -> a -> b
$ \Ptr CArb
x -> do
        forall {a}. (Ptr CArb -> IO a) -> IO (Arb, a)
withNewArb forall a b. (a -> b) -> a -> b
$ \Ptr CArb
y -> do
          Ptr CArb -> Ptr CArb -> Ptr CArb -> CLong -> IO ()
arb_sin_cos Ptr CArb
y Ptr CArb
x Ptr CArb
theta CLong
prec
          Ptr CAcb -> Ptr CArb -> Ptr CArb -> IO ()
acb_set_arb_arb Ptr CAcb
res Ptr CArb
x Ptr CArb
y
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Acb -> CF n
CF Acb
res

polar :: forall n. KnownNat n => (CF n) -> (RF n, RF n)
polar :: forall (n :: Nat). KnownNat n => CF n -> (RF n, RF n)
polar CF n
z = (forall (n :: Nat). KnownNat n => CF n -> RF n
magnitude CF n
z, forall (n :: Nat). KnownNat n => CF n -> RF n
phase CF n
z)

magnitude :: forall n. KnownNat n => (CF n) -> (RF n)
magnitude :: forall (n :: Nat). KnownNat n => CF n -> RF n
magnitude (CF Acb
z) = 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
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}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
z forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
z -> do
      Ptr CArb -> Ptr CAcb -> CLong -> IO ()
acb_abs Ptr CArb
res Ptr CAcb
z 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
res

phase :: forall n. KnownNat n => (CF n) -> (RF n)
phase :: forall (n :: Nat). KnownNat n => CF n -> RF n
phase (CF Acb
z) = 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
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}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
z forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
z -> do
      Ptr CArb -> Ptr CAcb -> CLong -> IO ()
acb_arg Ptr CArb
res Ptr CAcb
z 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
res

conjugate :: forall n. KnownNat n => (CF n) -> (CF n)
conjugate :: forall (n :: Nat). KnownNat n => CF n -> CF n
conjugate (CF Acb
z) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  Acb
res <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
res forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
res -> do
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
z forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
z -> do
      Ptr CAcb -> Ptr CAcb -> IO ()
acb_conj Ptr CAcb
res Ptr CAcb
z
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Acb -> CF n
CF Acb
res

instance forall n. KnownNat n => Eq (CF n) where
  {-# INLINE (==) #-}
  == :: CF n -> CF n -> Bool
(==) = forall (n :: Nat). KnownNat n => Cmp -> CF n -> CF n -> Bool
liftCmp Cmp
acb_eq
  {-# INLINE (/=) #-}
  /= :: CF n -> CF n -> Bool
(/=) = forall (n :: Nat). KnownNat n => Cmp -> CF n -> CF n -> Bool
liftCmp Cmp
acb_ne

instance forall n. KnownNat n => Ord (CF n) where
  compare :: CF n -> CF n -> Ordering
compare = forall a. HasCallStack => a
undefined
  
instance forall n. KnownNat n => Num (CF n) where
  {-# INLINE (+) #-}
  + :: CF n -> CF n -> CF n
(+) = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_add
  {-# INLINE (-) #-}
  (-) = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_sub
  {-# INLINE (*) #-}
  * :: CF n -> CF n -> CF n
(*) = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_mul
  {-# INLINE negate #-}
  negate :: CF n -> CF n
negate = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> IO ()) -> CF n -> CF n
lift1 Ptr CAcb -> Ptr CAcb -> IO ()
acb_neg
  abs :: CF n -> CF n
abs = forall a. HasCallStack => a
undefined
  {-# INLINE fromInteger #-}
  fromInteger :: Integer -> CF n
fromInteger Integer
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Acb
result <- IO Acb
newAcb
    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)
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
result forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
result -> do
      Ptr CAcb -> CULong -> IO ()
acb_set_ui Ptr CAcb
result (forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x)
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Acb -> CF n
CF Acb
result)
  signum :: CF n -> CF n
signum = forall a. HasCallStack => a
undefined
  
instance forall n. KnownNat n => Fractional (CF n) where
  {-# INLINE (/) #-}
  / :: CF n -> CF n -> CF n
(/) = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_div
  fromRational :: Rational -> CF n
fromRational Rational
x = CF n
p forall a. Fractional a => a -> a -> a
/ CF n
q where
    p :: CF n
p = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Ratio a -> a
numerator Rational
x) :: CF n
    q :: CF n
q = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Ratio a -> a
denominator Rational
x) :: CF n

instance forall n. KnownNat n => Real (CF n) where
  toRational :: CF n -> Rational
toRational = forall a. HasCallStack => a
undefined
  
instance forall n. KnownNat n => RealFrac (CF n) where
  properFraction :: forall b. Integral b => CF n -> (b, CF n)
properFraction = forall a. HasCallStack => a
undefined
  
instance forall n. KnownNat n => Floating (CF n) where
  pi :: CF n
pi = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_pi
  exp :: CF n -> CF n
exp = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_exp
  log :: CF n -> CF n
log = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_log
  sqrt :: CF n -> CF n
sqrt = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_sqrt
  sin :: CF n -> CF n
sin = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_sin
  cos :: CF n -> CF n
cos = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_cos
  tan :: CF n -> CF n
tan = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_tan
  asin :: CF n -> CF n
asin = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_asin
  acos :: CF n -> CF n
acos = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_acos
  atan :: CF n -> CF n
atan = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_atan
  sinh :: CF n -> CF n
sinh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_sinh
  cosh :: CF n -> CF n
cosh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_cosh
  tanh :: CF n -> CF n
tanh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_tanh
  asinh :: CF n -> CF n
asinh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_asinh
  acosh :: CF n -> CF n
acosh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_acosh
  atanh :: CF n -> CF n
atanh = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_atanh
  
instance forall n. KnownNat n => Show (CF n) where
  show :: CF n -> String
show (CF Acb
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)
    (Acb
_, CString
cstr) <- forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
p ->
      Ptr CAcb -> CLong -> CULong -> IO CString
acb_get_strn Ptr CAcb
p (forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
digits) CULong
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 => Special (CF n) where
  gamma :: CF n -> CF n
gamma = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_gamma
  digamma :: CF n -> CF n
digamma = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_digamma
  lgamma :: CF n -> CF n
lgamma = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_hypgeom_lgamma
  zeta :: CF n -> CF n
zeta = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_zeta
  erf :: CF n -> CF n
erf = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_hypgeom_erf
  airy :: CF n -> (CF n, CF n, CF n, CF n)
airy (CF Acb
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)
    Acb
ai <- IO Acb
newAcb
    Acb
ai' <- IO Acb
newAcb
    Acb
bi <- IO Acb
newAcb
    Acb
bi' <- IO Acb
newAcb
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
x -> 
      forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
ai forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
ai -> 
        forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
ai' forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
ai' ->
          forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
bi forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
bi ->
            forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
bi' forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
bi' ->
              Ptr CAcb -> Ptr CAcb -> Binary
acb_hypgeom_airy Ptr CAcb
ai Ptr CAcb
ai' Ptr CAcb
bi Ptr CAcb
bi' Ptr CAcb
x CLong
prec
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (forall (n :: Nat). Acb -> CF n
CF Acb
ai, forall (n :: Nat). Acb -> CF n
CF Acb
ai', forall (n :: Nat). Acb -> CF n
CF Acb
bi, forall (n :: Nat). Acb -> CF n
CF Acb
bi')
  airyZeros :: Fmpz -> (CF n, CF n, CF n, CF n)
airyZeros = forall a. HasCallStack => a
undefined
  besselJ :: CF n -> CF n -> CF n
besselJ = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_hypgeom_bessel_j
  besselY :: CF n -> CF n -> CF n
besselY = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_hypgeom_bessel_y
  besselI :: CF n -> CF n -> CF n
besselI = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_hypgeom_bessel_i
  besselK :: CF n -> CF n -> CF n
besselK = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_hypgeom_bessel_k
  modj :: CF n -> CF n
modj = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_modular_j
  modjq :: CF n -> CF n
modjq = forall a. HasCallStack => a
undefined
  modeta :: CF n -> CF n
modeta = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_modular_eta
  modetaq :: CF n -> CF n
modetaq = forall a. HasCallStack => a
undefined
  modlambda :: CF n -> CF n
modlambda = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_modular_lambda
  modlambdaq :: CF n -> CF n
modlambdaq = forall a. HasCallStack => a
undefined
  ellipp :: CF n -> CF n -> CF n
ellipp = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_elliptic_p
  ellipzeta :: CF n -> CF n -> CF n
ellipzeta = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_elliptic_zeta
  ellipsigma :: CF n -> CF n -> CF n
ellipsigma = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_elliptic_sigma
  barnesg :: CF n -> CF n
barnesg = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
acb_barnes_g
  agm :: CF n -> CF n -> CF n
agm = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_agm
  fresnels :: CF n -> CF n
fresnels = forall a. HasCallStack => a
undefined
  fresnelc :: CF n -> CF n
fresnelc = forall a. HasCallStack => a
undefined
    
instance forall n. KnownNat n => RF' (CF n) where
  euler :: CF n
euler = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_euler
  glaisher :: CF n
glaisher = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_glaisher
  catalan :: CF n
catalan = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_catalan
  khinchin :: CF n
khinchin = forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
arb_const_khinchin
  polylog :: CF n -> CF n -> CF n
polylog = forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
acb_polylog
  midPoint :: CF n -> CF n
midPoint = forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> IO ()) -> CF n -> CF n
lift1 Ptr CAcb -> Ptr CAcb -> IO ()
acb_get_mid
  
-- lifting -------------------------------------------------------------

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

lift2 :: forall n. KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 :: forall (n :: Nat). KnownNat n => Binary -> CF n -> CF n -> CF n
lift2 Binary
f (CF Acb
a) (CF Acb
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)
  Acb
c <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
a forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
a ->
    forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
b forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
b ->
      forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
c forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
c ->
        Binary
f Ptr CAcb
c Ptr CAcb
a Ptr CAcb
b (Int64 -> CLong
CLong Int64
prec)
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Acb -> CF n
CF Acb
c)

lift1 :: forall n. KnownNat n => Function -> CF n -> CF n
lift1 :: forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> IO ()) -> CF n -> CF n
lift1 Ptr CAcb -> Ptr CAcb -> IO ()
f (CF Acb
x) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  Acb
y <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
x -> forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
y forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
y -> Ptr CAcb -> Ptr CAcb -> IO ()
f Ptr CAcb
y Ptr CAcb
x
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Acb -> CF n
CF Acb
y)
  
lift0 :: (Ptr CAcb -> p -> IO b) -> p -> CF n
lift0 Ptr CAcb -> p -> IO b
f p
x = forall (n :: Nat). Acb -> CF n
CF 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 CAcb -> IO a) -> IO (Acb, a)
withNewAcb (Ptr CAcb -> p -> IO b
`f` p
x)
  
liftF1 :: forall n. KnownNat n =>
  (Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 :: forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> Ptr CAcb -> CLong -> IO ()) -> CF n -> CF n
liftF1 Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
f (CF Acb
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)
  Acb
y <- IO Acb
newAcb
  forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
x -> forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
y forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
y -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()
f Ptr CAcb
y Ptr CAcb
x (Int64 -> CLong
CLong Int64
prec)
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall (n :: Nat). Acb -> CF n
CF Acb
y)

liftCmp :: forall n. KnownNat n => Cmp -> CF n -> CF n -> Bool
liftCmp :: forall (n :: Nat). KnownNat n => Cmp -> CF n -> CF n -> Bool
liftCmp Cmp
f (CF Acb
x) (CF Acb
y) = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (Acb
_, (Acb
_, CInt
cmp)) <- forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
x -> forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
y forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
y -> Cmp
f Ptr CAcb
x Ptr CAcb
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 CAcb -> IO CInt) -> CF n -> Bool
liftProp :: forall (n :: Nat).
KnownNat n =>
(Ptr CAcb -> IO CInt) -> CF n -> Bool
liftProp Ptr CAcb -> IO CInt
f (CF Acb
x)  = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (Acb
_, CInt
prop) <- forall {a}. Acb -> (Ptr CAcb -> IO a) -> IO (Acb, a)
withAcb Acb
x forall a b. (a -> b) -> a -> b
$ \Ptr CAcb
x -> Ptr CAcb -> IO CInt
f Ptr CAcb
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 ()) -> CF n
liftConstant :: forall (n :: Nat).
KnownNat n =>
(Ptr CArb -> CLong -> IO ()) -> CF n
liftConstant Ptr CArb -> CLong -> IO ()
f = forall (n :: Nat). Acb -> CF n
CF forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ 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
tmp <- IO Arb
newArb
  forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
tmp forall a b. (a -> b) -> a -> b
$ \Ptr CArb
tmp -> do
    Ptr CArb -> CLong -> IO ()
f Ptr CArb
tmp CLong
prec
    forall {a}. (Ptr CAcb -> IO a) -> IO (Acb, a)
withNewAcb (Ptr CAcb -> Ptr CArb -> IO ()
`acb_set_arb` Ptr CArb
tmp)