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 = IO String -> String
forall a. IO a -> a
unsafePerformIO (IO String -> String) -> IO String -> String
forall a b. (a -> b) -> a -> b
$ do
    (Mag
_, CString
cs) <- Mag -> (Ptr CMag -> IO CString) -> IO (Mag, CString)
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
    CString -> IO ()
forall a. Ptr a -> IO ()
free CString
cs
    String -> IO String
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return String
s

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

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

instance Num Mag where
  + :: Mag -> Mag -> Mag
(+) = (Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()) -> 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
  (-) = (Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()) -> 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_sub
  * :: Mag -> Mag -> Mag
(*) = (Ptr CMag -> Ptr CMag -> Ptr CMag -> IO ()) -> 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 = Mag -> Mag
forall a. HasCallStack => a
undefined
  signum :: Mag -> Mag
signum = Mag -> Mag
forall a. HasCallStack => a
undefined
  fromInteger :: Integer -> Mag
fromInteger Integer
x = IO Mag -> Mag
forall a. IO a -> a
unsafePerformIO (IO Mag -> Mag) -> IO Mag -> Mag
forall a b. (a -> b) -> a -> b
$ do
    let tmp :: Fmpz
tmp = Integer -> Fmpz
forall a. Num a => Integer -> a
fromInteger Integer
x :: Fmpz
    Mag
result <- IO Mag
newMag
    Mag -> (Ptr CMag -> IO (Fmpz, ())) -> IO (Mag, (Fmpz, ()))
forall {a}. Mag -> (Ptr CMag -> IO a) -> IO (Mag, a)
withMag Mag
result ((Ptr CMag -> IO (Fmpz, ())) -> IO (Mag, (Fmpz, ())))
-> (Ptr CMag -> IO (Fmpz, ())) -> IO (Mag, (Fmpz, ()))
forall a b. (a -> b) -> a -> b
$ \Ptr CMag
p -> do
      Fmpz -> (Ptr CFmpz -> IO ()) -> IO (Fmpz, ())
forall {a}. Fmpz -> (Ptr CFmpz -> IO a) -> IO (Fmpz, a)
withFmpz Fmpz
tmp ((Ptr CFmpz -> IO ()) -> IO (Fmpz, ()))
-> (Ptr CFmpz -> IO ()) -> IO (Fmpz, ())
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
    Mag -> IO Mag
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Mag
result

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