{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE ViewPatterns #-}
--------------------------------------------------------------------------------
-- |
-- Module      : ArrayFire.FFI
-- Copyright   : David Johnson (c) 2019-2020
-- License     : BSD 3
-- Maintainer  : David Johnson <djohnson.m@gmail.com>
-- 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
           AFRandomEngine
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
           ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
           Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
           AFRandomEngine
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
           ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
           Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptr)

op2
  :: Array b
  -> Array a
  -> (Ptr AFArray -> AFArray -> AFArray -> IO AFErr)
  -> Array a
{-# NOINLINE op2 #-}
op2 :: forall b a.
Array b
-> Array a
-> (Ptr AFRandomEngine
    -> AFRandomEngine -> AFRandomEngine -> IO AFErr)
-> Array a
op2 (Array ForeignPtr ()
fptr1) (Array ForeignPtr ()
fptr2) Ptr 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
        AFRandomEngine
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
        ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
        Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
        AFRandomEngine
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
        ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
        Array CBool -> IO (Array CBool)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array CBool
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    (AFRandomEngine
x,AFRandomEngine
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 (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
    ForeignPtr ()
fptrA <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
x
    ForeignPtr ()
fptrB <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
y
    (Array a, Array a) -> IO (Array a, Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrA, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    (AFRandomEngine
x,AFRandomEngine
y,AFRandomEngine
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 (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 (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
    ForeignPtr ()
fptrA <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
x
    ForeignPtr ()
fptrB <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
y
    ForeignPtr ()
fptrC <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
z
    (Array a, Array a, Array a) -> IO (Array a, Array a, Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrA, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrB, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    (AFRandomEngine
x,AFRandomEngine
y,AFRandomEngine
z,b
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 (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 (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 (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
    ForeignPtr ()
fptrA <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
x
    ForeignPtr ()
fptrB <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
y
    ForeignPtr ()
fptrC <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
z
    (Array a, Array a, Array a, b) -> IO (Array a, Array a, Array a, b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrA, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrB, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrC, b
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
    (AFRandomEngine
x,AFRandomEngine
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 (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
    ForeignPtr ()
fptrA <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
x
    ForeignPtr ()
fptrB <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
y
    (Array a, Array a) -> IO (Array a, Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
fptrA, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
    Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
    Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_window_finalizer AFRandomEngine
ptr
    Window -> IO Window
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Window
Window ForeignPtr ()
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
      AFRandomEngine
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
      ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
      Array b -> IO (Array b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array b
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
      AFRandomEngine
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
      ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
ptr
      Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
      AFRandomEngine
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
      ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_features AFRandomEngine
ptr
      Features -> IO Features
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Features
Features ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_random_engine_finalizer AFRandomEngine
ptr
    RandomEngine -> IO RandomEngine
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> RandomEngine
RandomEngine ForeignPtr ()
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
      (AFRandomEngine
y,b
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 (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
      ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
y
      (b, Array a) -> IO (b, Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b
x, ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
p
    Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
    AFRandomEngine
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
    ForeignPtr ()
fptr <- FinalizerPtr () -> AFRandomEngine -> IO (ForeignPtr ())
forall a. FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
newForeignPtr FinalizerPtr ()
af_release_array_finalizer AFRandomEngine
p
    Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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
          ForeignPtr ()
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
          Array a -> IO (Array a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ForeignPtr () -> Array a
forall a. ForeignPtr () -> Array a
Array ForeignPtr ()
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 (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 (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 (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 (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 (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 (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 (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 ()