{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE ViewPatterns #-}
--------------------------------------------------------------------------------
-- |
-- Module      : ArrayFire.FFI
-- Copyright   : David Johnson (c) 2019-2020
-- License     : BSD 3
-- Maintainer  : David Johnson <code@dmj.io>
-- Stability   : Experimental
-- Portability : GHC
--
--------------------------------------------------------------------------------
module ArrayFire.FFI where

import ArrayFire.Exception
import ArrayFire.Types
import ArrayFire.Internal.Defines
import ArrayFire.Internal.Features
import ArrayFire.Internal.Array
import ArrayFire.Internal.Types

import Control.Exception
import Control.Monad
import Data.Int
import Foreign.ForeignPtr
import Foreign.Storable
import Foreign.Ptr
import Foreign.C
import Foreign.Marshal.Alloc
import System.IO.Unsafe

op3
  :: Array b
  -> Array a
  -> Array a
  -> (Ptr AFArray -> AFArray -> AFArray -> AFArray -> IO AFErr)
  -> Array a
{-# NOINLINE op3 #-}
op3 :: forall b a.
Array b
-> Array a
-> Array a
-> (Ptr AFRandomEngine
    -> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> Array a
op3 (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) (Array ForeignPtr ()
fptr3) Ptr AFRandomEngine
-> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> Array a
forall a. IO a -> a
unsafePerformIO (IO (Array a) -> Array a) -> IO (Array a) -> Array a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 ->
      ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
         ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr3 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr3 -> do
           ptr <-
             (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
               AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1 AFRandomEngine
ptr2 AFRandomEngine
ptr3
               Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
           fptr <- newForeignPtr af_release_array_finalizer ptr
           pure (Array fptr)

op3Int
  :: Array a
  -> Array Int32
  -> Array Int32
  -> (Ptr AFArray -> AFArray -> AFArray -> AFArray -> IO AFErr)
  -> Array a
{-# NOINLINE op3Int #-}
op3Int :: forall a.
Array a
-> Array Int32
-> Array Int32
-> (Ptr AFRandomEngine
    -> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> Array a
op3Int (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) (Array ForeignPtr ()
fptr3) Ptr AFRandomEngine
-> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> Array a
forall a. IO a -> a
unsafePerformIO (IO (Array a) -> Array a) -> IO (Array a) -> Array a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 ->
      ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
         ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr3 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr3 -> do
           ptr <-
             (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
               AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1 AFRandomEngine
ptr2 AFRandomEngine
ptr3
               Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
           fptr <- newForeignPtr af_release_array_finalizer ptr
           pure (Array fptr)

op2
  :: Array b
  -> Array a
  -> (Ptr AFArray -> AFArray -> AFArray -> IO AFErr)
  -> Array c
{-# NOINLINE op2 #-}
op2 :: forall b a c.
Array b
-> Array a
-> (Ptr AFRandomEngine
    -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> Array c
op2 (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) Ptr AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array c) -> Array c
forall a. IO a -> a
unsafePerformIO (IO (Array c) -> Array c) -> IO (Array c) -> Array c
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array c)) -> IO (Array c)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array c)) -> IO (Array c))
-> (AFRandomEngine -> IO (Array c)) -> IO (Array c)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 ->
      ForeignPtr () -> (AFRandomEngine -> IO (Array c)) -> IO (Array c)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (Array c)) -> IO (Array c))
-> (AFRandomEngine -> IO (Array c)) -> IO (Array c)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
        ptr <-
          (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
            AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1 AFRandomEngine
ptr2
            Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
        fptr <- newForeignPtr af_release_array_finalizer ptr
        pure (Array fptr)

op2bool
  :: Array b
  -> Array a
  -> (Ptr AFArray -> AFArray -> AFArray -> IO AFErr)
  -> Array CBool
{-# NOINLINE op2bool #-}
op2bool :: forall b a.
Array b
-> Array a
-> (Ptr AFRandomEngine
    -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> Array CBool
op2bool (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) Ptr AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array CBool) -> Array CBool
forall a. IO a -> a
unsafePerformIO (IO (Array CBool) -> Array CBool)
-> IO (Array CBool) -> Array CBool
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr ()
-> (AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool))
-> (AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 ->
      ForeignPtr ()
-> (AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool))
-> (AFRandomEngine -> IO (Array CBool)) -> IO (Array CBool)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
        ptr <-
          (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
            AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1 AFRandomEngine
ptr2
            Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
        fptr <- newForeignPtr af_release_array_finalizer ptr
        pure (Array fptr)


op2p
  :: Array a
  -> (Ptr AFArray -> Ptr AFArray -> AFArray -> IO AFErr)
  -> (Array a, Array a)
{-# NOINLINE op2p #-}
op2p :: forall a.
Array a
-> (Ptr AFRandomEngine
    -> Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> (Array a, Array a)
op2p (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine
-> Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array a, Array a) -> (Array a, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Array a, Array a) -> (Array a, Array a))
-> IO (Array a, Array a) -> (Array a, Array a)
forall a b. (a -> b) -> a -> b
$ do
    (x,y) <- ForeignPtr ()
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
        (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput1 -> do
          (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput2 -> do
            AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput1 Ptr AFRandomEngine
ptrInput2 AFRandomEngine
ptr1
            (,) (AFRandomEngine
 -> AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine
-> IO (AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput1 IO (AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput2
    fptrA <- newForeignPtr af_release_array_finalizer x
    fptrB <- newForeignPtr af_release_array_finalizer y
    pure (Array fptrA, Array fptrB)

op3p
  :: Array a
  -> (Ptr AFArray -> Ptr AFArray -> Ptr AFArray -> AFArray -> IO AFErr)
  -> (Array a, Array a, Array a)
{-# NOINLINE op3p #-}
op3p :: forall a.
Array a
-> (Ptr AFRandomEngine
    -> Ptr AFRandomEngine
    -> Ptr AFRandomEngine
    -> AFRandomEngine
    -> IO AFErr)
-> (Array a, Array a, Array a)
op3p (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> AFRandomEngine
-> IO AFErr
op =
  IO (Array a, Array a, Array a) -> (Array a, Array a, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Array a, Array a, Array a) -> (Array a, Array a, Array a))
-> IO (Array a, Array a, Array a) -> (Array a, Array a, Array a)
forall a b. (a -> b) -> a -> b
$ do
    (x,y,z) <- ForeignPtr ()
-> (AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> (AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
        (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput1 -> do
          (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput2 -> do
            (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput3 -> do
              AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> AFRandomEngine
-> IO AFErr
op Ptr AFRandomEngine
ptrInput1 Ptr AFRandomEngine
ptrInput2 Ptr AFRandomEngine
ptrInput3 AFRandomEngine
ptr1
              (,,) (AFRandomEngine
 -> AFRandomEngine
 -> AFRandomEngine
 -> (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine
-> IO
     (AFRandomEngine
      -> AFRandomEngine
      -> (AFRandomEngine, AFRandomEngine, AFRandomEngine))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput1 IO
  (AFRandomEngine
   -> AFRandomEngine
   -> (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine
-> IO
     (AFRandomEngine
      -> (AFRandomEngine, AFRandomEngine, AFRandomEngine))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput2 IO
  (AFRandomEngine
   -> (AFRandomEngine, AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput3
    fptrA <- newForeignPtr af_release_array_finalizer x
    fptrB <- newForeignPtr af_release_array_finalizer y
    fptrC <- newForeignPtr af_release_array_finalizer z
    pure (Array fptrA, Array fptrB, Array fptrC)

op3p1
  :: Storable b
  => Array a
  -> (Ptr AFArray -> Ptr AFArray -> Ptr AFArray -> Ptr b -> AFArray -> IO AFErr)
  -> (Array a, Array a, Array a, b)
{-# NOINLINE op3p1 #-}
op3p1 :: forall b a.
Storable b =>
Array a
-> (Ptr AFRandomEngine
    -> Ptr AFRandomEngine
    -> Ptr AFRandomEngine
    -> Ptr b
    -> AFRandomEngine
    -> IO AFErr)
-> (Array a, Array a, Array a, b)
op3p1 (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr b
-> AFRandomEngine
-> IO AFErr
op =
  IO (Array a, Array a, Array a, b) -> (Array a, Array a, Array a, b)
forall a. IO a -> a
unsafePerformIO (IO (Array a, Array a, Array a, b)
 -> (Array a, Array a, Array a, b))
-> IO (Array a, Array a, Array a, b)
-> (Array a, Array a, Array a, b)
forall a b. (a -> b) -> a -> b
$ do
    (x,y,z,g) <- ForeignPtr ()
-> (AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> (AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
        (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput1 -> do
          (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput2 -> do
            (Ptr AFRandomEngine
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine
  -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> (Ptr AFRandomEngine
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput3 -> do
              (Ptr b -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
 -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> (Ptr b
    -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput4 -> do
                AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> Ptr b
-> AFRandomEngine
-> IO AFErr
op Ptr AFRandomEngine
ptrInput1 Ptr AFRandomEngine
ptrInput2 Ptr AFRandomEngine
ptrInput3 Ptr b
ptrInput4 AFRandomEngine
ptr1
                (,,,) (AFRandomEngine
 -> AFRandomEngine
 -> AFRandomEngine
 -> b
 -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO AFRandomEngine
-> IO
     (AFRandomEngine
      -> AFRandomEngine
      -> b
      -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput1
                      IO
  (AFRandomEngine
   -> AFRandomEngine
   -> b
   -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO AFRandomEngine
-> IO
     (AFRandomEngine
      -> b -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput2
                      IO
  (AFRandomEngine
   -> b -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO AFRandomEngine
-> IO (b -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput3
                      IO (b -> (AFRandomEngine, AFRandomEngine, AFRandomEngine, b))
-> IO b -> IO (AFRandomEngine, AFRandomEngine, AFRandomEngine, b)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput4
    fptrA <- newForeignPtr af_release_array_finalizer x
    fptrB <- newForeignPtr af_release_array_finalizer y
    fptrC <- newForeignPtr af_release_array_finalizer z
    pure (Array fptrA, Array fptrB, Array fptrC, g)

op2p2
  :: Array a
  -> Array a
  -> (Ptr AFArray -> Ptr AFArray -> AFArray -> AFArray -> IO AFErr)
  -> (Array a, Array a)
{-# NOINLINE op2p2 #-}
op2p2 :: forall a.
Array a
-> Array a
-> (Ptr AFRandomEngine
    -> Ptr AFRandomEngine
    -> AFRandomEngine
    -> AFRandomEngine
    -> IO AFErr)
-> (Array a, Array a)
op2p2 (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> AFRandomEngine
-> AFRandomEngine
-> IO AFErr
op =
  IO (Array a, Array a) -> (Array a, Array a)
forall a. IO a -> a
unsafePerformIO (IO (Array a, Array a) -> (Array a, Array a))
-> IO (Array a, Array a) -> (Array a, Array a)
forall a b. (a -> b) -> a -> b
$ do
    (x,y) <-
      ForeignPtr ()
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
        ForeignPtr ()
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
          (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput1 -> do
            (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
 -> IO (AFRandomEngine, AFRandomEngine))
-> (Ptr AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine))
-> IO (AFRandomEngine, AFRandomEngine)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput2 -> do
              AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine
-> Ptr AFRandomEngine
-> AFRandomEngine
-> AFRandomEngine
-> IO AFErr
op Ptr AFRandomEngine
ptrInput1 Ptr AFRandomEngine
ptrInput2 AFRandomEngine
ptr1 AFRandomEngine
ptr2
              (,) (AFRandomEngine
 -> AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine
-> IO (AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput1 IO (AFRandomEngine -> (AFRandomEngine, AFRandomEngine))
-> IO AFRandomEngine -> IO (AFRandomEngine, AFRandomEngine)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput2
    fptrA <- newForeignPtr af_release_array_finalizer x
    fptrB <- newForeignPtr af_release_array_finalizer y
    pure (Array fptrA, Array fptrB)

createArray'
  :: (Ptr AFArray -> IO AFErr)
  -> IO (Array a)
{-# NOINLINE createArray' #-}
createArray' :: forall a. (Ptr AFRandomEngine -> IO AFErr) -> IO (Array a)
createArray' Ptr AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> IO (Array a)
forall a. IO a -> IO a
mask_ (IO (Array a) -> IO (Array a)) -> IO (Array a) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ do
    ptr <-
      (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
        Ptr AFRandomEngine -> IO ()
zeroOutArray Ptr AFRandomEngine
ptrInput
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput
        Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
    fptr <- newForeignPtr af_release_array_finalizer ptr
    pure (Array fptr)

createArray
  :: (Ptr AFArray -> IO AFErr)
  -> Array a
{-# NOINLINE createArray #-}
createArray :: forall a. (Ptr AFRandomEngine -> IO AFErr) -> Array a
createArray Ptr AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> Array a
forall a. IO a -> a
unsafePerformIO (IO (Array a) -> Array a)
-> (IO (Array a) -> IO (Array a)) -> IO (Array a) -> Array a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Array a) -> IO (Array a)
forall a. IO a -> IO a
mask_ (IO (Array a) -> Array a) -> IO (Array a) -> Array a
forall a b. (a -> b) -> a -> b
$ do
    ptr <-
      (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
        Ptr AFRandomEngine -> IO ()
zeroOutArray Ptr AFRandomEngine
ptrInput
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput
        Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
    fptr <- newForeignPtr af_release_array_finalizer ptr
    pure (Array fptr)

createWindow'
  :: (Ptr AFWindow -> IO AFErr)
  -> IO Window
createWindow' :: (Ptr AFRandomEngine -> IO AFErr) -> IO Window
createWindow' Ptr AFRandomEngine -> IO AFErr
op =
  IO Window -> IO Window
forall a. IO a -> IO a
mask_ (IO Window -> IO Window) -> IO Window -> IO Window
forall a b. (a -> b) -> a -> b
$ do
    ptr <-
      (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput
        Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
    fptr <- newForeignPtr af_release_window_finalizer ptr
    pure (Window fptr)

opw
  :: Window
  -> (AFWindow -> IO AFErr)
  -> IO ()
opw :: Window -> (AFRandomEngine -> IO AFErr) -> IO ()
opw (Window ForeignPtr ()
fptr) AFRandomEngine -> IO AFErr
op
  = IO () -> IO ()
forall a. IO a -> IO a
mask_ (IO () -> IO ())
-> ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ())
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFRandomEngine -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ (AFErr -> IO ()
throwAFError (AFErr -> IO ())
-> (AFRandomEngine -> IO AFErr) -> AFRandomEngine -> IO ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< AFRandomEngine -> IO AFErr
op)

opw1
  :: Storable a
  => Window
  -> (Ptr a -> AFWindow -> IO AFErr)
  -> IO a
{-# NOINLINE opw1 #-}
opw1 :: forall a.
Storable a =>
Window -> (Ptr a -> AFRandomEngine -> IO AFErr) -> IO a
opw1 (Window ForeignPtr ()
fptr) Ptr a -> AFRandomEngine -> IO AFErr
op
  = IO a -> IO a
forall a. IO a -> IO a
mask_ (IO a -> IO a)
-> ((AFRandomEngine -> IO a) -> IO a)
-> (AFRandomEngine -> IO a)
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFRandomEngine -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFRandomEngine -> IO a) -> IO a)
-> (AFRandomEngine -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr -> do
       (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
p -> do
         AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> AFRandomEngine -> IO AFErr
op Ptr a
p AFRandomEngine
ptr
         Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
p

op1d
  :: Array a
  -> (Ptr AFArray -> AFArray -> IO AFErr)
  -> Array b
{-# NOINLINE op1d #-}
op1d :: forall a b.
Array a
-> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr) -> Array b
op1d (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array b) -> Array b
forall a. IO a -> a
unsafePerformIO (IO (Array b) -> Array b) -> IO (Array b) -> Array b
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array b)) -> IO (Array b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array b)) -> IO (Array b))
-> (AFRandomEngine -> IO (Array b)) -> IO (Array b)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      ptr <-
        (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1
          Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
      fptr <- newForeignPtr af_release_array_finalizer ptr
      pure (Array fptr)


op1
  :: Array a
  -> (Ptr AFArray -> AFArray -> IO AFErr)
  -> Array a
{-# NOINLINE op1 #-}
op1 :: forall a.
Array a
-> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr) -> Array a
op1 (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> Array a
forall a. IO a -> a
unsafePerformIO (IO (Array a) -> Array a) -> IO (Array a) -> Array a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      ptr <-
        (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1
          Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
      fptr <- newForeignPtr af_release_array_finalizer ptr
      pure (Array fptr)

op1f
  :: Features
  -> (Ptr AFFeatures -> AFFeatures -> IO AFErr)
  -> Features
{-# NOINLINE op1f #-}
op1f :: Features
-> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr) -> Features
op1f (Features ForeignPtr ()
x) Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO Features -> Features
forall a. IO a -> a
unsafePerformIO (IO Features -> Features)
-> (IO Features -> IO Features) -> IO Features -> Features
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO Features -> IO Features
forall a. IO a -> IO a
mask_ (IO Features -> Features) -> IO Features -> Features
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO Features) -> IO Features
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
x ((AFRandomEngine -> IO Features) -> IO Features)
-> (AFRandomEngine -> IO Features) -> IO Features
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      ptr <-
        (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1
          Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
      fptr <- newForeignPtr af_release_features ptr
      pure (Features fptr)

op1re
  :: RandomEngine
  -> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr)
  -> IO RandomEngine
op1re :: RandomEngine
-> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> IO RandomEngine
op1re (RandomEngine ForeignPtr ()
x) Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op = IO RandomEngine -> IO RandomEngine
forall a. IO a -> IO a
mask_ (IO RandomEngine -> IO RandomEngine)
-> IO RandomEngine -> IO RandomEngine
forall a b. (a -> b) -> a -> b
$
  ForeignPtr ()
-> (AFRandomEngine -> IO RandomEngine) -> IO RandomEngine
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
x ((AFRandomEngine -> IO RandomEngine) -> IO RandomEngine)
-> (AFRandomEngine -> IO RandomEngine) -> IO RandomEngine
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
    ptr <-
      (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1
        Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
    fptr <- newForeignPtr af_release_random_engine_finalizer ptr
    pure (RandomEngine fptr)

op1b
  :: Storable b
  => Array a
  -> (Ptr AFArray -> Ptr b -> AFArray -> IO AFErr)
  -> (b, Array a)
{-# NOINLINE op1b #-}
op1b :: forall b a.
Storable b =>
Array a
-> (Ptr AFRandomEngine -> Ptr b -> AFRandomEngine -> IO AFErr)
-> (b, Array a)
op1b (Array ForeignPtr ()
fptr1) Ptr AFRandomEngine -> Ptr b -> AFRandomEngine -> IO AFErr
op =
  IO (b, Array a) -> (b, Array a)
forall a. IO a -> a
unsafePerformIO (IO (b, Array a) -> (b, Array a))
-> IO (b, Array a) -> (b, Array a)
forall a b. (a -> b) -> a -> b
$
    ForeignPtr ()
-> (AFRandomEngine -> IO (b, Array a)) -> IO (b, Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (b, Array a)) -> IO (b, Array a))
-> (AFRandomEngine -> IO (b, Array a)) -> IO (b, Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (y,x) <-
        (Ptr AFRandomEngine -> IO (AFRandomEngine, b))
-> IO (AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (AFRandomEngine, b))
 -> IO (AFRandomEngine, b))
-> (Ptr AFRandomEngine -> IO (AFRandomEngine, b))
-> IO (AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput1 -> do
          (Ptr b -> IO (AFRandomEngine, b)) -> IO (AFRandomEngine, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (AFRandomEngine, b)) -> IO (AFRandomEngine, b))
-> (Ptr b -> IO (AFRandomEngine, b)) -> IO (AFRandomEngine, b)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput2 -> do
            AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> Ptr b -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput1 Ptr b
ptrInput2 AFRandomEngine
ptr1
            (,) (AFRandomEngine -> b -> (AFRandomEngine, b))
-> IO AFRandomEngine -> IO (b -> (AFRandomEngine, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput1 IO (b -> (AFRandomEngine, b)) -> IO b -> IO (AFRandomEngine, b)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput2
      fptr <- newForeignPtr af_release_array_finalizer y
      pure (x, Array fptr)

afCall
  :: IO AFErr
  -> IO ()
afCall :: IO AFErr -> IO ()
afCall = IO () -> IO ()
forall a. IO a -> IO a
mask_ (IO () -> IO ()) -> (IO AFErr -> IO ()) -> IO AFErr -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<)

loadAFImage
  :: String
  -> Bool
  -> (Ptr AFArray -> CString -> CBool -> IO AFErr)
  -> IO (Array a)
loadAFImage :: forall a.
String
-> Bool
-> (Ptr AFRandomEngine -> CString -> CBool -> IO AFErr)
-> IO (Array a)
loadAFImage String
s (Int -> CBool
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CBool) -> (Bool -> Int) -> Bool -> CBool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum -> CBool
b) Ptr AFRandomEngine -> CString -> CBool -> IO AFErr
op = IO (Array a) -> IO (Array a)
forall a. IO a -> IO a
mask_ (IO (Array a) -> IO (Array a)) -> IO (Array a) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$
  String -> (CString -> IO (Array a)) -> IO (Array a)
forall a. String -> (CString -> IO a) -> IO a
withCString String
s ((CString -> IO (Array a)) -> IO (Array a))
-> (CString -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \CString
cstr -> do
    p <- (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptr -> do
      AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> CString -> CBool -> IO AFErr
op Ptr AFRandomEngine
ptr CString
cstr CBool
b
      Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptr
    fptr <- newForeignPtr af_release_array_finalizer p
    pure (Array fptr)

loadAFImageNative
  :: String
  -> (Ptr AFArray -> CString -> IO AFErr)
  -> IO (Array a)
loadAFImageNative :: forall a.
String
-> (Ptr AFRandomEngine -> CString -> IO AFErr) -> IO (Array a)
loadAFImageNative String
s Ptr AFRandomEngine -> CString -> IO AFErr
op = IO (Array a) -> IO (Array a)
forall a. IO a -> IO a
mask_ (IO (Array a) -> IO (Array a)) -> IO (Array a) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$
  String -> (CString -> IO (Array a)) -> IO (Array a)
forall a. String -> (CString -> IO a) -> IO a
withCString String
s ((CString -> IO (Array a)) -> IO (Array a))
-> (CString -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \CString
cstr -> do
    p <- (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine)
-> (Ptr AFRandomEngine -> IO AFRandomEngine) -> IO AFRandomEngine
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptr -> do
      AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> CString -> IO AFErr
op Ptr AFRandomEngine
ptr CString
cstr
      Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptr
    fptr <- newForeignPtr af_release_array_finalizer p
    pure (Array fptr)

inPlace :: Array a -> (AFArray -> IO AFErr) -> IO ()
inPlace :: forall a. Array a -> (AFRandomEngine -> IO AFErr) -> IO ()
inPlace (Array ForeignPtr ()
fptr) AFRandomEngine -> IO AFErr
op =
  IO () -> IO ()
forall a. IO a -> IO a
mask_ (IO () -> IO ())
-> ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ())
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFRandomEngine -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ (AFErr -> IO ()
throwAFError (AFErr -> IO ())
-> (AFRandomEngine -> IO AFErr) -> AFRandomEngine -> IO ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< AFRandomEngine -> IO AFErr
op)

inPlaceEng :: RandomEngine -> (AFRandomEngine -> IO AFErr) -> IO ()
inPlaceEng :: RandomEngine -> (AFRandomEngine -> IO AFErr) -> IO ()
inPlaceEng (RandomEngine ForeignPtr ()
fptr) AFRandomEngine -> IO AFErr
op =
  IO () -> IO ()
forall a. IO a -> IO a
mask_ (IO () -> IO ())
-> ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ())
-> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr () -> (AFRandomEngine -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ (AFErr -> IO ()
throwAFError (AFErr -> IO ())
-> (AFRandomEngine -> IO AFErr) -> AFRandomEngine -> IO ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< AFRandomEngine -> IO AFErr
op)

afCall1
  :: Storable a
  => (Ptr a -> IO AFErr)
  -> IO a
afCall1 :: forall a. Storable a => (Ptr a -> IO AFErr) -> IO a
afCall1 Ptr a -> IO AFErr
op =
  (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput -> do
    AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> IO AFErr
op Ptr a
ptrInput
    Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput

afCall1'
  :: Storable a
  => (Ptr a -> IO AFErr)
  -> a
{-# NOINLINE afCall1' #-}
afCall1' :: forall a. Storable a => (Ptr a -> IO AFErr) -> a
afCall1' Ptr a -> IO AFErr
op =
  IO a -> a
forall a. IO a -> a
unsafePerformIO (IO a -> a) -> (IO a -> IO a) -> IO a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> IO a
forall a. IO a -> IO a
mask_ (IO a -> a) -> IO a -> a
forall a b. (a -> b) -> a -> b
$ do
    (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput -> do
      AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> IO AFErr
op Ptr a
ptrInput
      Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput

-- | Note: We don't add a finalizer to 'Array' since the 'Features' finalizer frees 'Array'
-- under the hood.
featuresToArray
  :: Features
  -> (Ptr AFArray -> AFFeatures -> IO AFErr)
  -> Array a
{-# NOINLINE featuresToArray #-}
featuresToArray :: forall a.
Features
-> (Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr) -> Array a
featuresToArray (Features ForeignPtr ()
fptr1) Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (Array a) -> Array a
forall a. IO a -> a
unsafePerformIO (IO (Array a) -> Array a)
-> (IO (Array a) -> IO (Array a)) -> IO (Array a) -> Array a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Array a) -> IO (Array a)
forall a. IO a -> IO a
mask_ (IO (Array a) -> Array a) -> IO (Array a) -> Array a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr AFRandomEngine
ptrInput AFRandomEngine
ptr1
        (Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a))
-> (Ptr AFRandomEngine -> IO (Array a)) -> IO (Array a)
forall a b. (a -> b) -> a -> b
$ \Ptr AFRandomEngine
retainedArray -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> AFRandomEngine -> IO AFErr
af_retain_array Ptr AFRandomEngine
retainedArray (AFRandomEngine -> IO AFErr) -> IO AFRandomEngine -> IO AFErr
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
ptrInput
          fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer (AFRandomEngine -> IO (ForeignPtr ()))
-> IO AFRandomEngine -> IO (ForeignPtr ())
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr AFRandomEngine -> IO AFRandomEngine
forall a. Storable a => Ptr a -> IO a
peek Ptr AFRandomEngine
retainedArray
          pure (Array fptr)

infoFromFeatures
  :: Storable a
  => Features
  -> (Ptr a -> AFFeatures -> IO AFErr)
  -> a
{-# NOINLINE infoFromFeatures #-}
infoFromFeatures :: forall a.
Storable a =>
Features -> (Ptr a -> AFRandomEngine -> IO AFErr) -> a
infoFromFeatures (Features ForeignPtr ()
fptr1) Ptr a -> AFRandomEngine -> IO AFErr
op =
  IO a -> a
forall a. IO a -> a
unsafePerformIO (IO a -> a) -> IO a -> a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO a) -> IO a)
-> (AFRandomEngine -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput AFRandomEngine
ptr1
        Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput

infoFromRandomEngine
  :: Storable a
  => RandomEngine
  -> (Ptr a -> AFRandomEngine -> IO AFErr)
  -> IO a
infoFromRandomEngine :: forall a.
Storable a =>
RandomEngine -> (Ptr a -> AFRandomEngine -> IO AFErr) -> IO a
infoFromRandomEngine (RandomEngine ForeignPtr ()
fptr1) Ptr a -> AFRandomEngine -> IO AFErr
op =
  IO a -> IO a
forall a. IO a -> IO a
mask_ (IO a -> IO a) -> IO a -> IO a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO a) -> IO a)
-> (AFRandomEngine -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput AFRandomEngine
ptr1
        Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput

afSaveImage
  :: Array b
  -> String
  -> (CString -> AFArray -> IO AFErr)
  -> IO ()
afSaveImage :: forall b.
Array b
-> String -> (CString -> AFRandomEngine -> IO AFErr) -> IO ()
afSaveImage (Array ForeignPtr ()
fptr1) String
str CString -> AFRandomEngine -> IO AFErr
op =
  String -> (CString -> IO ()) -> IO ()
forall a. String -> (CString -> IO a) -> IO a
withCString String
str ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CString
cstr ->
    ForeignPtr () -> (AFRandomEngine -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO ()) -> IO ())
-> (AFRandomEngine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$
      AFErr -> IO ()
throwAFError (AFErr -> IO ())
-> (AFRandomEngine -> IO AFErr) -> AFRandomEngine -> IO ()
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< CString -> AFRandomEngine -> IO AFErr
op CString
cstr

infoFromArray
  :: Storable a
  => Array b
  -> (Ptr a -> AFArray -> IO AFErr)
  -> a
{-# NOINLINE infoFromArray #-}
infoFromArray :: forall a b.
Storable a =>
Array b -> (Ptr a -> AFRandomEngine -> IO AFErr) -> a
infoFromArray (Array ForeignPtr ()
fptr1) Ptr a -> AFRandomEngine -> IO AFErr
op =
  IO a -> a
forall a. IO a -> a
unsafePerformIO (IO a -> a) -> IO a -> a
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO a) -> IO a)
-> (AFRandomEngine -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr a -> IO a) -> IO a
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO a) -> IO a) -> (Ptr a -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput -> do
        AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput AFRandomEngine
ptr1
        Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput

infoFromArray2
  :: (Storable a, Storable b)
  => Array arr
  -> (Ptr a -> Ptr b -> AFArray -> IO AFErr)
  -> (a,b)
{-# NOINLINE infoFromArray2 #-}
infoFromArray2 :: forall a b arr.
(Storable a, Storable b) =>
Array arr
-> (Ptr a -> Ptr b -> AFRandomEngine -> IO AFErr) -> (a, b)
infoFromArray2 (Array ForeignPtr ()
fptr1) Ptr a -> Ptr b -> AFRandomEngine -> IO AFErr
op =
  IO (a, b) -> (a, b)
forall a. IO a -> a
unsafePerformIO (IO (a, b) -> (a, b)) -> IO (a, b) -> (a, b)
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (a, b)) -> IO (a, b))
-> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr a -> IO (a, b)) -> IO (a, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO (a, b)) -> IO (a, b))
-> (Ptr a -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput1 -> do
        (Ptr b -> IO (a, b)) -> IO (a, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (a, b)) -> IO (a, b))
-> (Ptr b -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput2 -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> Ptr b -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput1 Ptr b
ptrInput2 AFRandomEngine
ptr1
          (,) (a -> b -> (a, b)) -> IO a -> IO (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput1 IO (b -> (a, b)) -> IO b -> IO (a, b)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput2

infoFromArray22
  :: (Storable a, Storable b)
  => Array arr
  -> Array arr
  -> (Ptr a -> Ptr b -> AFArray -> AFArray -> IO AFErr)
  -> (a,b)
{-# NOINLINE infoFromArray22 #-}
infoFromArray22 :: forall a b arr.
(Storable a, Storable b) =>
Array arr
-> Array arr
-> (Ptr a -> Ptr b -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> (a, b)
infoFromArray22 (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) Ptr a -> Ptr b -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op =
  IO (a, b) -> (a, b)
forall a. IO a -> a
unsafePerformIO (IO (a, b) -> (a, b)) -> IO (a, b) -> (a, b)
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr () -> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (a, b)) -> IO (a, b))
-> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
     ForeignPtr () -> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr2 ((AFRandomEngine -> IO (a, b)) -> IO (a, b))
-> (AFRandomEngine -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr2 -> do
      (Ptr a -> IO (a, b)) -> IO (a, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO (a, b)) -> IO (a, b))
-> (Ptr a -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput1 -> do
        (Ptr b -> IO (a, b)) -> IO (a, b)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (a, b)) -> IO (a, b))
-> (Ptr b -> IO (a, b)) -> IO (a, b)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput2 -> do
          AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> Ptr b -> AFRandomEngine -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput1 Ptr b
ptrInput2 AFRandomEngine
ptr1 AFRandomEngine
ptr2
          (,) (a -> b -> (a, b)) -> IO a -> IO (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput1 IO (b -> (a, b)) -> IO b -> IO (a, b)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput2

infoFromArray3
  :: (Storable a, Storable b, Storable c)
  => Array arr
  -> (Ptr a -> Ptr b -> Ptr c -> AFArray -> IO AFErr)
  -> (a,b,c)
{-# NOINLINE infoFromArray3 #-}
infoFromArray3 :: forall a b c arr.
(Storable a, Storable b, Storable c) =>
Array arr
-> (Ptr a -> Ptr b -> Ptr c -> AFRandomEngine -> IO AFErr)
-> (a, b, c)
infoFromArray3 (Array ForeignPtr ()
fptr1) Ptr a -> Ptr b -> Ptr c -> AFRandomEngine -> IO AFErr
op =
  IO (a, b, c) -> (a, b, c)
forall a. IO a -> a
unsafePerformIO (IO (a, b, c) -> (a, b, c)) -> IO (a, b, c) -> (a, b, c)
forall a b. (a -> b) -> a -> b
$
    ForeignPtr () -> (AFRandomEngine -> IO (a, b, c)) -> IO (a, b, c)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (a, b, c)) -> IO (a, b, c))
-> (AFRandomEngine -> IO (a, b, c)) -> IO (a, b, c)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 -> do
      (Ptr a -> IO (a, b, c)) -> IO (a, b, c)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO (a, b, c)) -> IO (a, b, c))
-> (Ptr a -> IO (a, b, c)) -> IO (a, b, c)
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput1 -> do
        (Ptr b -> IO (a, b, c)) -> IO (a, b, c)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (a, b, c)) -> IO (a, b, c))
-> (Ptr b -> IO (a, b, c)) -> IO (a, b, c)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput2 -> do
          (Ptr c -> IO (a, b, c)) -> IO (a, b, c)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr c -> IO (a, b, c)) -> IO (a, b, c))
-> (Ptr c -> IO (a, b, c)) -> IO (a, b, c)
forall a b. (a -> b) -> a -> b
$ \Ptr c
ptrInput3 -> do
            AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> Ptr b -> Ptr c -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput1 Ptr b
ptrInput2 Ptr c
ptrInput3 AFRandomEngine
ptr1
            (,,) (a -> b -> c -> (a, b, c)) -> IO a -> IO (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput1
                 IO (b -> c -> (a, b, c)) -> IO b -> IO (c -> (a, b, c))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput2
                 IO (c -> (a, b, c)) -> IO c -> IO (a, b, c)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr c -> IO c
forall a. Storable a => Ptr a -> IO a
peek Ptr c
ptrInput3

infoFromArray4
  :: (Storable a, Storable b, Storable c, Storable d)
  => Array arr
  -> (Ptr a -> Ptr b -> Ptr c -> Ptr d -> AFArray -> IO AFErr)
  -> (a,b,c,d)
{-# NOINLINE infoFromArray4 #-}
infoFromArray4 :: forall a b c d arr.
(Storable a, Storable b, Storable c, Storable d) =>
Array arr
-> (Ptr a -> Ptr b -> Ptr c -> Ptr d -> AFRandomEngine -> IO AFErr)
-> (a, b, c, d)
infoFromArray4 (Array ForeignPtr ()
fptr1) Ptr a -> Ptr b -> Ptr c -> Ptr d -> AFRandomEngine -> IO AFErr
op =
  IO (a, b, c, d) -> (a, b, c, d)
forall a. IO a -> a
unsafePerformIO (IO (a, b, c, d) -> (a, b, c, d))
-> IO (a, b, c, d) -> (a, b, c, d)
forall a b. (a -> b) -> a -> b
$
    ForeignPtr ()
-> (AFRandomEngine -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ()
fptr1 ((AFRandomEngine -> IO (a, b, c, d)) -> IO (a, b, c, d))
-> (AFRandomEngine -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \AFRandomEngine
ptr1 ->
      (Ptr a -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr a -> IO (a, b, c, d)) -> IO (a, b, c, d))
-> (Ptr a -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \Ptr a
ptrInput1 ->
        (Ptr b -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr b -> IO (a, b, c, d)) -> IO (a, b, c, d))
-> (Ptr b -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \Ptr b
ptrInput2 ->
          (Ptr c -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr c -> IO (a, b, c, d)) -> IO (a, b, c, d))
-> (Ptr c -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \Ptr c
ptrInput3 ->
            (Ptr d -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr d -> IO (a, b, c, d)) -> IO (a, b, c, d))
-> (Ptr d -> IO (a, b, c, d)) -> IO (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \Ptr d
ptrInput4 -> do
              AFErr -> IO ()
throwAFError (AFErr -> IO ()) -> IO AFErr -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr a -> Ptr b -> Ptr c -> Ptr d -> AFRandomEngine -> IO AFErr
op Ptr a
ptrInput1 Ptr b
ptrInput2 Ptr c
ptrInput3 Ptr d
ptrInput4 AFRandomEngine
ptr1
              (,,,) (a -> b -> c -> d -> (a, b, c, d))
-> IO a -> IO (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Ptr a -> IO a
forall a. Storable a => Ptr a -> IO a
peek Ptr a
ptrInput1
                    IO (b -> c -> d -> (a, b, c, d))
-> IO b -> IO (c -> d -> (a, b, c, d))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr b -> IO b
forall a. Storable a => Ptr a -> IO a
peek Ptr b
ptrInput2
                    IO (c -> d -> (a, b, c, d)) -> IO c -> IO (d -> (a, b, c, d))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr c -> IO c
forall a. Storable a => Ptr a -> IO a
peek Ptr c
ptrInput3
                    IO (d -> (a, b, c, d)) -> IO d -> IO (a, b, c, d)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr d -> IO d
forall a. Storable a => Ptr a -> IO a
peek Ptr d
ptrInput4

foreign import ccall unsafe "zeroOutArray"
  zeroOutArray :: Ptr AFArray -> IO ()