{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-}
module Data.Number.Flint.NMod.Poly.Instances (
    NModPoly (..)
  , 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.NMod.Poly
import Data.Number.Flint.NMod.Poly.Factor

import Data.Number.Flint.UFD

instance Show NModPoly where
  show :: NModPoly -> String
show NModPoly
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}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
p forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
p -> do
      forall a. String -> (CString -> IO a) -> IO a
withCString String
"x" forall a b. (a -> b) -> a -> b
$ \CString
x -> do
        CString
cs <- Ptr CNModPoly -> CString -> IO CString
nmod_poly_get_str_pretty Ptr CNModPoly
p CString
x
        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 Num NModPoly where
  * :: NModPoly -> NModPoly -> NModPoly
(*) = forall {a}.
(Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a)
-> NModPoly -> NModPoly -> NModPoly
lift2 Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_mul
  + :: NModPoly -> NModPoly -> NModPoly
(+) = forall {a}.
(Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a)
-> NModPoly -> NModPoly -> NModPoly
lift2 Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_add
  (-) = forall {a}.
(Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a)
-> NModPoly -> NModPoly -> NModPoly
lift2 Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_sub
  abs :: NModPoly -> NModPoly
abs = forall a. HasCallStack => a
undefined
  signum :: NModPoly -> NModPoly
signum = forall a. HasCallStack => a
undefined
  fromInteger :: Integer -> NModPoly
fromInteger = forall a. HasCallStack => a
undefined
  
instance Semigroup NModPoly where
  <> :: NModPoly -> NModPoly -> NModPoly
(<>) = forall {a}.
(Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a)
-> NModPoly -> NModPoly -> NModPoly
lift2 Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_compose

instance Eq NModPoly where
  == :: NModPoly -> NModPoly -> Bool
(==) NModPoly
x NModPoly
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}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x ->
      forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
y -> do
        CInt
f <- Ptr CNModPoly -> Ptr CNModPoly -> IO CInt
nmod_poly_equal Ptr CNModPoly
x Ptr CNModPoly
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 NModPoly where
  compare :: NModPoly -> NModPoly -> Ordering
compare = forall a. HasCallStack => a
undefined
  
instance Real NModPoly where
  toRational :: NModPoly -> Rational
toRational = forall a. HasCallStack => a
undefined

instance Enum NModPoly where
  toEnum :: Int -> NModPoly
toEnum = forall a. HasCallStack => a
undefined
  fromEnum :: NModPoly -> Int
fromEnum = forall a. HasCallStack => a
undefined
  
instance Integral NModPoly where
  toInteger :: NModPoly -> Integer
toInteger = forall a. HasCallStack => a
undefined
  div :: NModPoly -> NModPoly -> NModPoly
div NModPoly
x NModPoly
y = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    (NModPoly
_, CMpLimb
n) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
    (NModPoly
_, CMpLimb
m) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CMpLimb
n forall a. Eq a => a -> a -> Bool
/= CMpLimb
m) forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => String -> a
error String
"modulus does not agree."
    NModPoly
p <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n
    NModPoly
q <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n
    forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x ->
      forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
y ->
        forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
q forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
q ->
          Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_div Ptr CNModPoly
q Ptr CNModPoly
x Ptr CNModPoly
y
    forall (m :: * -> *) a. Monad m => a -> m a
return NModPoly
q
  quotRem :: NModPoly -> NModPoly -> (NModPoly, NModPoly)
quotRem NModPoly
x NModPoly
y = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    (NModPoly
_, CMpLimb
n) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
    (NModPoly
_, CMpLimb
m) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CMpLimb
n forall a. Eq a => a -> a -> Bool
/= CMpLimb
m) forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => String -> a
error String
"modulus does not agree."
    NModPoly
p <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n 
    NModPoly
q <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n
    forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x ->
      forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
y ->
        forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
p forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
p ->
          forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
q forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
q ->
            Ptr CNModPoly
-> Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_divrem Ptr CNModPoly
p Ptr CNModPoly
q Ptr CNModPoly
x Ptr CNModPoly
y
    forall (m :: * -> *) a. Monad m => a -> m a
return (NModPoly
p, NModPoly
q)

instance UFD NModPoly where
  factor :: NModPoly -> [(NModPoly, Int)]
factor NModPoly
x = 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}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x -> do
      CMpLimb
m <- Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus Ptr CNModPoly
x
      NModPolyFactor
f <- IO NModPolyFactor
newNModPolyFactor
      forall {a}.
NModPolyFactor
-> (Ptr CNModPolyFactor -> IO a) -> IO (NModPolyFactor, a)
withNModPolyFactor NModPolyFactor
f forall a b. (a -> b) -> a -> b
$ \Ptr CNModPolyFactor
f -> do
        Ptr CNModPolyFactor -> Ptr CNModPoly -> IO CMpLimb
nmod_poly_factor Ptr CNModPolyFactor
f Ptr CNModPoly
x
        (CNModPolyFactor Ptr CNModPoly
d Ptr CLong
e CLong
n CLong
alloc) <- forall a. Storable a => Ptr a -> IO a
peek Ptr CNModPolyFactor
f
        forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Int
0..forall a b. (Integral a, Num b) => a -> b
fromIntegral CLong
nforall a. Num a => a -> a -> a
-Int
1] forall a b. (a -> b) -> a -> b
$ \Int
j -> do
          CLong
m <- forall a. Storable a => Ptr a -> IO a
peek (Ptr CLong
e forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
j)
          NModPoly
r <- CMpLimb -> IO NModPoly
newNModPoly (forall a b. (Integral a, Num b) => a -> b
fromIntegral CLong
m)
          forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
r forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
r -> Ptr CNModPoly -> Ptr CNModPoly -> IO ()
nmod_poly_set Ptr CNModPoly
r (Ptr CNModPoly
d forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
j)
          forall (m :: * -> *) a. Monad m => a -> m a
return (NModPoly
r, forall a b. (Integral a, Num b) => a -> b
fromIntegral CLong
m)

lift2 :: (Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a)
-> NModPoly -> NModPoly -> NModPoly
lift2 Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a
f NModPoly
x NModPoly
y = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (NModPoly
_, CMpLimb
n) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
  (NModPoly
_, CMpLimb
m) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (CMpLimb
n forall a. Eq a => a -> a -> Bool
/= CMpLimb
m) forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => String -> a
error String
"modulus does not agree."
  NModPoly
result <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n
  forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
result forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
result -> do
    forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x -> do
      forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
y forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
y -> do
        Ptr CNModPoly -> Ptr CNModPoly -> Ptr CNModPoly -> IO a
f Ptr CNModPoly
result Ptr CNModPoly
x Ptr CNModPoly
y
  forall (m :: * -> *) a. Monad m => a -> m a
return NModPoly
result

lift1 :: (Ptr CNModPoly -> Ptr CNModPoly -> IO a) -> NModPoly -> NModPoly
lift1 Ptr CNModPoly -> Ptr CNModPoly -> IO a
f NModPoly
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
  (NModPoly
_, CMpLimb
n) <- forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x Ptr CNModPoly -> IO CMpLimb
nmod_poly_modulus
  NModPoly
result <- CMpLimb -> IO NModPoly
newNModPoly CMpLimb
n
  forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
result forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
result ->
    forall {a}. NModPoly -> (Ptr CNModPoly -> IO a) -> IO (NModPoly, a)
withNModPoly NModPoly
x forall a b. (a -> b) -> a -> b
$ \Ptr CNModPoly
x ->
    Ptr CNModPoly -> Ptr CNModPoly -> IO a
f Ptr CNModPoly
result Ptr CNModPoly
x
  forall (m :: * -> *) a. Monad m => a -> m a
return NModPoly
result