{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-}
module Data.Number.Flint.Arb.Poly.Instances (
    ArbPoly (..)
  , module GHC.Exts
) where

import Test.QuickCheck

import GHC.Exts

import System.IO.Unsafe
import Control.Monad

import Foreign.Ptr
import Foreign.C.String
import Foreign.Storable
import Foreign.Marshal.Alloc (free)
import Foreign.Marshal.Array (advancePtr)

import Data.Number.Flint.Arb
import Data.Number.Flint.Arb.Instances
import Data.Number.Flint.Arb.Poly

import Data.Number.Flint.UFD

instance Show ArbPoly where
  show :: ArbPoly -> String
show ArbPoly
p = 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
    forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
p forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
p -> do
      CString
cs <- Ptr CArbPoly -> CLong -> IO CString
arb_poly_get_strd Ptr CArbPoly
p CLong
16
      String
s <- CString -> IO String
peekCString CString
cs
      forall a. Ptr a -> IO ()
free CString
cs
      forall (m :: * -> *) a. Monad m => a -> m a
return String
s

instance IsList ArbPoly where
  type Item ArbPoly = Arb
  fromList :: [Item ArbPoly] -> ArbPoly
fromList [Item ArbPoly]
c = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    ArbPoly
p <- IO ArbPoly
newArbPoly
    forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
p forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
p -> 
      forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [Int
0..forall (t :: * -> *) a. Foldable t => t a -> Int
length [Item ArbPoly]
cforall a. Num a => a -> a -> a
-Int
1] forall a b. (a -> b) -> a -> b
$ \Int
j ->
        forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb ([Item ArbPoly]
cforall a. [a] -> Int -> a
!!Int
j) forall a b. (a -> b) -> a -> b
$ \Ptr CArb
a -> 
          Ptr CArbPoly -> CLong -> Ptr CArb -> IO ()
arb_poly_set_coeff_arb Ptr CArbPoly
p (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
j) Ptr CArb
a
    forall (m :: * -> *) a. Monad m => a -> m a
return ArbPoly
p
  toList :: ArbPoly -> [Item ArbPoly]
toList ArbPoly
p = 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
$ 
    forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
p forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
p -> do
      CLong
d <- Ptr CArbPoly -> IO CLong
arb_poly_degree Ptr CArbPoly
p
      forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [CLong
0..CLong
d] forall a b. (a -> b) -> a -> b
$ \CLong
j -> do
        Arb
c <- IO Arb
newArb
        forall {a}. Arb -> (Ptr CArb -> IO a) -> IO (Arb, a)
withArb Arb
c forall a b. (a -> b) -> a -> b
$ \Ptr CArb
c -> Ptr CArb -> Ptr CArbPoly -> CLong -> IO ()
arb_poly_get_coeff_arb Ptr CArb
c Ptr CArbPoly
p CLong
j
        forall (m :: * -> *) a. Monad m => a -> m a
return Arb
c

lift2 :: (Ptr CArbPoly -> Ptr CArbPoly -> Ptr CArbPoly -> IO a)
-> ArbPoly -> ArbPoly -> ArbPoly
lift2 Ptr CArbPoly -> Ptr CArbPoly -> Ptr CArbPoly -> IO a
f ArbPoly
x ArbPoly
y = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  ArbPoly
result <- IO ArbPoly
newArbPoly
  forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
result forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
result -> do
    forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
x -> do
      forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
y forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
y -> do
        Ptr CArbPoly -> Ptr CArbPoly -> Ptr CArbPoly -> IO a
f Ptr CArbPoly
result Ptr CArbPoly
x Ptr CArbPoly
y
  forall (m :: * -> *) a. Monad m => a -> m a
return ArbPoly
result

lift1 :: (Ptr CArbPoly -> Ptr CArbPoly -> IO a) -> ArbPoly -> ArbPoly
lift1 Ptr CArbPoly -> Ptr CArbPoly -> IO a
f ArbPoly
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  ArbPoly
result <- IO ArbPoly
newArbPoly
  forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
result forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
result ->
    forall {a}. ArbPoly -> (Ptr CArbPoly -> IO a) -> IO (ArbPoly, a)
withArbPoly ArbPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CArbPoly
x ->
    Ptr CArbPoly -> Ptr CArbPoly -> IO a
f Ptr CArbPoly
result Ptr CArbPoly
x
  forall (m :: * -> *) a. Monad m => a -> m a
return ArbPoly
result