module Data.Number.Flint.Arb.Mag.Instances (
  Mag (..)
) where

import System.IO.Unsafe
import Foreign.C.String
import Foreign.Marshal.Alloc

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

instance Show Mag where
  show :: Mag -> String
show Mag
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    (Mag
_, CString
cs) <- forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
x Ptr CMag -> IO CString
mag_get_str
    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 Eq Mag where
  == :: Mag -> Mag -> Bool
(==) Mag
x Mag
y = forall a b. (a, b) -> b
snd 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
    forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
x forall a b. (a -> b) -> a -> b
$ \Ptr CMag
x -> do
      forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
y forall a b. (a -> b) -> a -> b
$ \Ptr CMag
y -> do
        CInt
f <- Ptr CMag -> Ptr CMag -> IO CInt
mag_equal Ptr CMag
x Ptr CMag
y
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CInt
f forall a. Eq a => a -> a -> Bool
== CInt
1

instance Ord Mag where
  compare :: Mag -> Mag -> Ordering
compare Mag
x Mag
y = forall a b. (a, b) -> b
snd 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
    forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
x forall a b. (a -> b) -> a -> b
$ \Ptr CMag
x -> do
      forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
y forall a b. (a -> b) -> a -> b
$ \Ptr CMag
y -> do
        CInt
f <- Ptr CMag -> Ptr CMag -> IO CInt
mag_cmp Ptr CMag
x Ptr CMag
y
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CInt
f forall a. Ord a => a -> a -> Ordering
`compare` CInt
0

instance Num Mag where
  + :: Mag -> Mag -> Mag
(+) = forall {a}.
(Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag -> Mag
lift2 Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()
mag_add
  (-) = forall {a}.
(Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag -> Mag
lift2 Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()
mag_sub
  * :: Mag -> Mag -> Mag
(*) = forall {a}.
(Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag -> Mag
lift2 Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()
mag_mul
  abs :: Mag -> Mag
abs = forall a. HasCallStack => a
undefined
  signum :: Mag -> Mag
signum = forall a. HasCallStack => a
undefined
  fromInteger :: Integer -> Mag
fromInteger Integer
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    let tmp :: Fmpz
tmp = forall a. Num a => Integer -> a
fromInteger Integer
x :: Fmpz
    Mag
result <- IO Mag
newMag
    forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
result forall a b. (a -> b) -> a -> b
$ \Ptr CMag
p -> do
      forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
tmp forall a b. (a -> b) -> a -> b
$ \Ptr CFmpz
tmp -> do
        Ptr CMag -> Ptr CFmpz -> IO ()
mag_set_fmpz Ptr CMag
p Ptr CFmpz
tmp
    forall (m :: * -> *) a. Monad m => a -> m a
return Mag
result

instance Fractional Mag where
  / :: Mag -> Mag -> Mag
(/) = forall {a}.
(Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag -> Mag
lift2 Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()
mag_div
  recip :: Mag -> Mag
recip = forall {a}. (Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag
lift1 Ptr CMag -> Ptr CMag -> IO ()
mag_inv
  fromRational :: Rational -> Mag
fromRational = forall a. HasCallStack => a
undefined
  
lift1 :: (Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag
lift1 Ptr CMag -> Ptr CMag -> IO a
f Mag
x = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ 
  forall {a}. (Ptr CMag -> IO a) -> IO (Mag, a)
withNewMag forall a b. (a -> b) -> a -> b
$ \Ptr CMag
result -> 
    forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
x forall a b. (a -> b) -> a -> b
$ \Ptr CMag
x ->
      Ptr CMag -> Ptr CMag -> IO a
f Ptr CMag
result Ptr CMag
x
 
lift2 :: (Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a) -> Mag -> Mag -> Mag
lift2 Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a
f Mag
x Mag
y = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  Mag
result <- IO Mag
newMag
  forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
result forall a b. (a -> b) -> a -> b
$ \Ptr CMag
result -> do
    forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
x forall a b. (a -> b) -> a -> b
$ \Ptr CMag
x -> do
      forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
y forall a b. (a -> b) -> a -> b
$ \Ptr CMag
y -> do
        Ptr CMag -> Ptr CMag -> Ptr CMag -> IO a
f Ptr CMag
result Ptr CMag
x Ptr CMag
y
  forall (m :: * -> *) a. Monad m => a -> m a
return Mag
result