{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

-- |
-- Module      : Data.Massiv.Array.Manifest.Boxed
-- Copyright   : (c) Alexey Kuleshevich 2018-2022
-- License     : BSD3
-- Maintainer  : Alexey Kuleshevich <lehins@yandex.ru>
-- Stability   : experimental
-- Portability : non-portable
module Data.Massiv.Array.Manifest.Boxed (
  B (..),
  BL (..),
  BN (..),
  N,
  pattern N,
  Array (..),
  MArray (..),
  wrapLazyArray,
  unwrapLazyArray,
  unwrapNormalForm,
  evalNormalForm,
  unwrapArray,
  evalArray,
  toLazyArray,
  evalLazyArray,
  forceLazyArray,
  unwrapMutableArray,
  unwrapMutableLazyArray,
  evalMutableArray,
  unwrapNormalFormArray,
  evalNormalFormArray,
  unwrapNormalFormMutableArray,
  evalNormalFormMutableArray,
  toBoxedVector,
  toBoxedMVector,
  fromBoxedVector,
  fromBoxedMVector,
  evalBoxedVector,
  evalBoxedMVector,
  evalNormalBoxedVector,
  evalNormalBoxedMVector,
  coerceBoxedArray,
  coerceNormalBoxedArray,
  seqArray,
  deepseqArray,
) where

import Control.DeepSeq (NFData (..), deepseq)
import Control.Exception
import Control.Monad ((>=>))
import Control.Monad.Primitive
import qualified Data.Foldable as F (Foldable (..))
import Data.Massiv.Array.Delayed.Pull (D)
import Data.Massiv.Array.Delayed.Push (DL)
import Data.Massiv.Array.Delayed.Stream (DS)
import Data.Massiv.Array.Manifest.Internal (compute, computeAs)
import Data.Massiv.Array.Manifest.List as L
import Data.Massiv.Array.Mutable
import Data.Massiv.Array.Ops.Fold
import Data.Massiv.Array.Ops.Fold.Internal
import Data.Massiv.Array.Ops.Map (traverseA)
import Data.Massiv.Core.Common
import Data.Massiv.Core.List
import Data.Massiv.Core.Operations
import Data.Massiv.Vector.Stream as S (isteps, steps)
import qualified Data.Primitive.Array as A
import qualified Data.Vector as VB
import qualified Data.Vector.Mutable as MVB
import GHC.Exts as GHC
import System.IO.Unsafe (unsafePerformIO)
import Prelude hiding (mapM, replicate)
#if !MIN_VERSION_vector(0,13,0)
import Unsafe.Coerce (unsafeCoerce)
#endif

#include "massiv.h"

----------------
-- Boxed Lazy --
----------------

-- | Array representation for Boxed elements. This data structure is lazy with
-- respect to its elements.
--
-- ====__Example__
--
-- Memoized version of a factorial that relies on laziness. Note that
-- computing memoized factorial of a million would likely overflow memory.
--
-- >>> import Data.Massiv.Array as A
-- >>> :{
-- mkMemoFactorial :: Int -> (Int -> Integer)
-- mkMemoFactorial n =
--   let arr = makeVectorR BL Seq (Sz1 n) fact
--       fact i | i == 0 = 1
--              | otherwise = (arr ! (i - 1)) * toInteger i
--   in (arr !)
-- :}
--
-- >>> let fact = mkMemoFactorial 1000001
-- >>> fact 50
-- 30414093201713378043612608166064768844377641568960512000000000000
-- >>> length $ show $ fact 5000
-- 16326
data BL = BL deriving (Int -> BL -> ShowS
[BL] -> ShowS
BL -> String
(Int -> BL -> ShowS)
-> (BL -> String) -> ([BL] -> ShowS) -> Show BL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BL -> ShowS
showsPrec :: Int -> BL -> ShowS
$cshow :: BL -> String
show :: BL -> String
$cshowList :: [BL] -> ShowS
showList :: [BL] -> ShowS
Show)

data instance Array BL ix e = BLArray
  { forall ix e. Array BL ix e -> Comp
blComp :: !Comp
  , forall ix e. Array BL ix e -> Sz ix
blSize :: !(Sz ix)
  , forall ix e. Array BL ix e -> Int
blOffset :: {-# UNPACK #-} !Int
  , forall ix e. Array BL ix e -> Array e
blData :: {-# UNPACK #-} !(A.Array e)
  }

data instance MArray s BL ix e
  = MBLArray !(Sz ix) {-# UNPACK #-} !Int {-# UNPACK #-} !(A.MutableArray s e)

instance (Ragged L ix e, Show e) => Show (Array BL ix e) where
  showsPrec :: Int -> Array BL ix e -> ShowS
showsPrec = (Array BL ix e -> Array BL ix e) -> Int -> Array BL ix e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec Array BL ix e -> Array BL ix e
forall a. a -> a
id
  showList :: [Array BL ix e] -> ShowS
showList = [Array BL ix e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

instance (Ragged L ix e, Show e) => Show (Array DL ix e) where
  showsPrec :: Int -> Array DL ix e -> ShowS
showsPrec = (Array DL ix e -> Array BL ix e) -> Int -> Array DL ix e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec (BL -> Array DL ix e -> Array BL ix e
forall r e r' ix.
(Manifest r e, Load r' ix e) =>
r -> Array r' ix e -> Array r ix e
computeAs BL
BL)
  showList :: [Array DL ix e] -> ShowS
showList = [Array DL ix e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

instance Show e => Show (Array DS Ix1 e) where
  showsPrec :: Int -> Array DS Int e -> ShowS
showsPrec = (Array DS Int e -> Array BL Int e)
-> Int -> Array DS Int e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec (BL -> Array DS Int e -> Array BL Int e
forall r e r' ix.
(Manifest r e, Load r' ix e) =>
r -> Array r' ix e -> Array r ix e
computeAs BL
BL)
  showList :: [Array DS Int e] -> ShowS
showList = [Array DS Int e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

instance (Index ix, NFData e) => NFData (Array BL ix e) where
  rnf :: Array BL ix e -> ()
rnf = (Array BL ix e -> () -> ()
forall a ix t. (NFData a, Index ix) => Array BL ix a -> t -> t
`deepseqArray` ())
  {-# INLINE rnf #-}

instance (Index ix, Eq e) => Eq (Array BL ix e) where
  == :: Array BL ix e -> Array BL ix e -> Bool
(==) = (e -> e -> Bool) -> Array BL ix e -> Array BL ix e -> Bool
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool
eqArrays e -> e -> Bool
forall a. Eq a => a -> a -> Bool
(==)
  {-# INLINE (==) #-}

instance (Index ix, Ord e) => Ord (Array BL ix e) where
  compare :: Array BL ix e -> Array BL ix e -> Ordering
compare = (e -> e -> Ordering) -> Array BL ix e -> Array BL ix e -> Ordering
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Ordering)
-> Array r1 ix e1 -> Array r2 ix e2 -> Ordering
compareArrays e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
  {-# INLINE compare #-}

instance Strategy BL where
  setComp :: forall ix e. Comp -> Array BL ix e -> Array BL ix e
setComp Comp
c Array BL ix e
arr = Array BL ix e
arr{blComp = c}
  {-# INLINE setComp #-}
  getComp :: forall ix e. Array BL ix e -> Comp
getComp = Array BL ix e -> Comp
forall ix e. Array BL ix e -> Comp
blComp
  {-# INLINE getComp #-}
  repr :: BL
repr = BL
BL

instance Source BL e where
  unsafeLinearIndex :: forall ix. Index ix => Array BL ix e -> Int -> e
unsafeLinearIndex (BLArray Comp
_ Sz ix
_sz Int
o Array e
a) Int
i =
    String
-> (Array e -> Sz1) -> (Array e -> Int -> e) -> Array e -> Int -> e
forall a ix e.
String -> (a -> Sz ix) -> (a -> ix -> e) -> a -> ix -> e
indexAssert String
"BL.unsafeLinearIndex" (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array e -> Int) -> Array e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array e -> Int
forall a. Array a -> Int
A.sizeofArray) Array e -> Int -> e
forall a. Array a -> Int -> a
A.indexArray Array e
a (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o)
  {-# INLINE unsafeLinearIndex #-}

  unsafeOuterSlice :: forall ix.
(Index ix, Index (Lower ix)) =>
Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
unsafeOuterSlice (BLArray Comp
c Sz ix
_ Int
o Array e
a) Sz (Lower ix)
szL Int
i = Comp -> Sz (Lower ix) -> Int -> Array e -> Array BL (Lower ix) e
forall ix e. Comp -> Sz ix -> Int -> Array e -> Array BL ix e
BLArray Comp
c Sz (Lower ix)
szL (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Sz (Lower ix) -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz (Lower ix)
szL Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o) Array e
a
  {-# INLINE unsafeOuterSlice #-}

  unsafeLinearSlice :: forall ix.
Index ix =>
Int -> Sz1 -> Array BL ix e -> Array BL Int e
unsafeLinearSlice Int
i Sz1
k (BLArray Comp
c Sz ix
_ Int
o Array e
a) = Comp -> Sz1 -> Int -> Array e -> Array BL Int e
forall ix e. Comp -> Sz ix -> Int -> Array e -> Array BL ix e
BLArray Comp
c Sz1
k (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Array e
a
  {-# INLINE unsafeLinearSlice #-}

instance Manifest BL e where
  unsafeLinearIndexM :: forall ix. Index ix => Array BL ix e -> Int -> e
unsafeLinearIndexM (BLArray Comp
_ Sz ix
_sz Int
o Array e
a) Int
i =
    String
-> (Array e -> Sz1) -> (Array e -> Int -> e) -> Array e -> Int -> e
forall a ix e.
String -> (a -> Sz ix) -> (a -> ix -> e) -> a -> ix -> e
indexAssert String
"BL.unsafeLinearIndexM" (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array e -> Int) -> Array e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array e -> Int
forall a. Array a -> Int
A.sizeofArray) Array e -> Int -> e
forall a. Array a -> Int -> a
A.indexArray Array e
a (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o)
  {-# INLINE unsafeLinearIndexM #-}

  sizeOfMArray :: forall ix s. Index ix => MArray s BL ix e -> Sz ix
sizeOfMArray (MBLArray Sz ix
sz Int
_ MutableArray s e
_) = Sz ix
sz
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: forall ix' ix s.
(Index ix', Index ix) =>
Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
unsafeResizeMArray Sz ix'
sz (MBLArray Sz ix
_ Int
off MutableArray s e
marr) = Sz ix' -> Int -> MutableArray s e -> MArray s BL ix' e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray Sz ix'
sz Int
off MutableArray s e
marr
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: forall ix s.
Index ix =>
Int -> Sz1 -> MArray s BL ix e -> MVector s BL e
unsafeLinearSliceMArray Int
i Sz1
k (MBLArray Sz ix
_ Int
o MutableArray s e
a) = Sz1 -> Int -> MutableArray s e -> MArray s BL Int e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray Sz1
k (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o) MutableArray s e
a
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Array BL ix e -> m (MArray (PrimState m) BL ix e)
unsafeThaw (BLArray Comp
_ Sz ix
sz Int
o Array e
a) = Sz ix
-> Int
-> MutableArray (PrimState m) e
-> MArray (PrimState m) BL ix e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray Sz ix
sz Int
o (MutableArray (PrimState m) e -> MArray (PrimState m) BL ix e)
-> m (MutableArray (PrimState m) e)
-> m (MArray (PrimState m) BL ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array e -> m (MutableArray (PrimState m) e)
forall (m :: * -> *) a.
PrimMonad m =>
Array a -> m (MutableArray (PrimState m) a)
A.unsafeThawArray Array e
a
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
unsafeFreeze Comp
comp (MBLArray Sz ix
sz Int
o MutableArray (PrimState m) e
ma) = Comp -> Sz ix -> Int -> Array e -> Array BL ix e
forall ix e. Comp -> Sz ix -> Int -> Array e -> Array BL ix e
BLArray Comp
comp Sz ix
sz Int
o (Array e -> Array BL ix e) -> m (Array e) -> m (Array BL ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MutableArray (PrimState m) e -> m (Array e)
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
A.unsafeFreezeArray MutableArray (PrimState m) e
ma
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) BL ix e)
unsafeNew Sz ix
sz = Sz ix
-> Int
-> MutableArray (PrimState m) e
-> MArray (PrimState m) BL ix e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray Sz ix
sz Int
0 (MutableArray (PrimState m) e -> MArray (PrimState m) BL ix e)
-> m (MutableArray (PrimState m) e)
-> m (MArray (PrimState m) BL ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> e -> m (MutableArray (PrimState m) e)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
A.newArray (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz) e
forall a. a
uninitialized
  {-# INLINE unsafeNew #-}

  initialize :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> m ()
initialize MArray (PrimState m) BL ix e
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  {-# INLINE initialize #-}

  newMArray :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BL ix e)
newMArray Sz ix
sz e
e = Sz ix
-> Int
-> MutableArray (PrimState m) e
-> MArray (PrimState m) BL ix e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray Sz ix
sz Int
0 (MutableArray (PrimState m) e -> MArray (PrimState m) BL ix e)
-> m (MutableArray (PrimState m) e)
-> m (MArray (PrimState m) BL ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> e -> m (MutableArray (PrimState m) e)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
A.newArray (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz) e
e
  {-# INLINE newMArray #-}

  unsafeLinearRead :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> m e
unsafeLinearRead (MBLArray Sz ix
_ Int
o MutableArray (PrimState m) e
ma) Int
i =
    String
-> (MutableArray (PrimState m) e -> Sz1)
-> (MutableArray (PrimState m) e -> Int -> m e)
-> MutableArray (PrimState m) e
-> Int
-> m e
forall a ix e.
String -> (a -> Sz ix) -> (a -> ix -> e) -> a -> ix -> e
indexAssert String
"B.unsafeLinearRead" (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1)
-> (MutableArray (PrimState m) e -> Int)
-> MutableArray (PrimState m) e
-> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MutableArray (PrimState m) e -> Int
forall s a. MutableArray s a -> Int
A.sizeofMutableArray) MutableArray (PrimState m) e -> Int -> m e
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
A.readArray MutableArray (PrimState m) e
ma (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> e -> m ()
unsafeLinearWrite (MBLArray Sz ix
_sz Int
o MutableArray (PrimState m) e
ma) Int
i =
    String
-> (MutableArray (PrimState m) e -> Sz1)
-> (MutableArray (PrimState m) e -> Int -> e -> m ())
-> MutableArray (PrimState m) e
-> Int
-> e
-> m ()
forall a ix e.
String -> (a -> Sz ix) -> (a -> ix -> e) -> a -> ix -> e
indexAssert String
"B.unsafeLinearWrite" (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1)
-> (MutableArray (PrimState m) e -> Int)
-> MutableArray (PrimState m) e
-> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MutableArray (PrimState m) e -> Int
forall s a. MutableArray s a -> Int
A.sizeofMutableArray) MutableArray (PrimState m) e -> Int -> e -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
A.writeArray MutableArray (PrimState m) e
ma (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o)
  {-# INLINE unsafeLinearWrite #-}

instance Size BL where
  size :: forall ix e. Array BL ix e -> Sz ix
size = Array BL ix e -> Sz ix
forall ix e. Array BL ix e -> Sz ix
blSize
  {-# INLINE size #-}
  unsafeResize :: forall ix ix' e.
(Index ix, Index ix') =>
Sz ix' -> Array BL ix e -> Array BL ix' e
unsafeResize !Sz ix'
sz !Array BL ix e
arr = Array BL ix e
arr{blSize = sz}
  {-# INLINE unsafeResize #-}

instance Index ix => Shape BL ix where
  maxLinearSize :: forall e. Array BL ix e -> Maybe Sz1
maxLinearSize = Sz1 -> Maybe Sz1
forall a. a -> Maybe a
Just (Sz1 -> Maybe Sz1)
-> (Array BL ix e -> Sz1) -> Array BL ix e -> Maybe Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array BL ix e -> Int) -> Array BL ix e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BL ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount
  {-# INLINE maxLinearSize #-}

instance Index ix => Load BL ix e where
  makeArray :: Comp -> Sz ix -> (ix -> e) -> Array BL ix e
makeArray Comp
comp Sz ix
sz ix -> e
f = Array D ix e -> Array BL ix e
forall r ix e r'.
(Manifest r e, Load r' ix e) =>
Array r' ix e -> Array r ix e
compute (Comp -> Sz ix -> (ix -> e) -> Array D ix e
forall r ix e.
Load r ix e =>
Comp -> Sz ix -> (ix -> e) -> Array r ix e
makeArray Comp
comp Sz ix
sz ix -> e
f :: Array D ix e)
  {-# INLINE makeArray #-}

  makeArrayLinear :: Comp -> Sz ix -> (Int -> e) -> Array BL ix e
makeArrayLinear !Comp
comp !Sz ix
sz Int -> e
f = IO (Array BL ix e) -> Array BL ix e
forall a. IO a -> a
unsafePerformIO (IO (Array BL ix e) -> Array BL ix e)
-> IO (Array BL ix e) -> Array BL ix e
forall a b. (a -> b) -> a -> b
$ Comp -> Sz ix -> (Int -> IO e) -> IO (Array BL ix e)
forall r ix e (m :: * -> *).
(MonadUnliftIO m, Manifest r e, Index ix) =>
Comp -> Sz ix -> (Int -> m e) -> m (Array r ix e)
generateArrayLinear Comp
comp Sz ix
sz (e -> IO e
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> IO e) -> (Int -> e) -> Int -> IO e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> e
f)
  {-# INLINE makeArrayLinear #-}

  replicate :: Comp -> Sz ix -> e -> Array BL ix e
replicate Comp
comp Sz ix
sz e
e = (forall s. ST s (Array BL ix e)) -> Array BL ix e
forall a. (forall s. ST s a) -> a
runST (Sz ix -> e -> ST s (MArray (PrimState (ST s)) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BL ix e)
newMArray Sz ix
sz e
e ST s (MArray s BL ix e)
-> (MArray s BL ix e -> ST s (Array BL ix e))
-> ST s (Array BL ix e)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Comp -> MArray (PrimState (ST s)) BL ix e -> ST s (Array BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}

  iterArrayLinearST_ :: forall s.
Scheduler s () -> Array BL ix e -> (Int -> e -> ST s ()) -> ST s ()
iterArrayLinearST_ !Scheduler s ()
scheduler !Array BL ix e
arr =
    Scheduler s ()
-> Int -> (Int -> e) -> (Int -> e -> ST s ()) -> ST s ()
forall s (m :: * -> *) b.
MonadPrimBase s m =>
Scheduler s () -> Int -> (Int -> b) -> (Int -> b -> m ()) -> m ()
splitLinearlyWith_ Scheduler s ()
scheduler (Array BL ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount Array BL ix e
arr) (Array BL ix e -> Int -> e
forall ix. Index ix => Array BL ix e -> Int -> e
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array BL ix e
arr)
  {-# INLINE iterArrayLinearST_ #-}

instance Index ix => StrideLoad BL ix e

instance Index ix => Stream BL ix e where
  toStream :: Array BL ix e -> Steps Id e
toStream = Array BL ix e -> Steps Id e
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m e
S.steps
  {-# INLINE toStream #-}
  toStreamIx :: Array BL ix e -> Steps Id (ix, e)
toStreamIx = Array BL ix e -> Steps Id (ix, e)
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m (ix, e)
S.isteps
  {-# INLINE toStreamIx #-}

-- | Row-major sequential folding over a Boxed array.
instance Index ix => Foldable (Array BL ix) where
  fold :: forall m. Monoid m => Array BL ix m -> m
fold = Array BL ix m -> m
forall e ix r.
(Monoid e, Index ix, Source r e) =>
Array r ix e -> e
fold
  {-# INLINE fold #-}
  foldMap :: forall m a. Monoid m => (a -> m) -> Array BL ix a -> m
foldMap = (a -> m) -> Array BL ix a -> m
forall ix r e m.
(Index ix, Source r e, Monoid m) =>
(e -> m) -> Array r ix e -> m
foldMono
  {-# INLINE foldMap #-}
  foldl :: forall b a. (b -> a -> b) -> b -> Array BL ix a -> b
foldl = (b -> a -> b) -> b -> Array BL ix a -> b
forall ix r e a.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> Array r ix e -> a
lazyFoldlS
  {-# INLINE foldl #-}
  foldl' :: forall b a. (b -> a -> b) -> b -> Array BL ix a -> b
foldl' = (b -> a -> b) -> b -> Array BL ix a -> b
forall ix r e a.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> Array r ix e -> a
foldlS
  {-# INLINE foldl' #-}
  foldr :: forall a b. (a -> b -> b) -> b -> Array BL ix a -> b
foldr = (a -> b -> b) -> b -> Array BL ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrFB
  {-# INLINE foldr #-}
  foldr' :: forall a b. (a -> b -> b) -> b -> Array BL ix a -> b
foldr' = (a -> b -> b) -> b -> Array BL ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrS
  {-# INLINE foldr' #-}
  null :: forall a. Array BL ix a -> Bool
null (BLArray Comp
_ Sz ix
sz Int
_ Array a
_) = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
  {-# INLINE null #-}
  length :: forall a. Array BL ix a -> Int
length = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem (Sz ix -> Int) -> (Array BL ix a -> Sz ix) -> Array BL ix a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BL ix a -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array BL ix e -> Sz ix
size
  {-# INLINE length #-}
  toList :: forall a. Array BL ix a -> [a]
toList Array BL ix a
arr = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\a -> b -> b
c b
n -> (a -> b -> b) -> b -> Array BL ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrFB a -> b -> b
c b
n Array BL ix a
arr)
  {-# INLINE toList #-}

instance Index ix => Functor (Array BL ix) where
  fmap :: forall a b. (a -> b) -> Array BL ix a -> Array BL ix b
fmap a -> b
f Array BL ix a
arr = Comp -> Sz ix -> (Int -> b) -> Array BL ix b
forall r ix e.
Load r ix e =>
Comp -> Sz ix -> (Int -> e) -> Array r ix e
makeArrayLinear (Array BL ix a -> Comp
forall ix e. Array BL ix e -> Comp
blComp Array BL ix a
arr) (Array BL ix a -> Sz ix
forall ix e. Array BL ix e -> Sz ix
blSize Array BL ix a
arr) (a -> b
f (a -> b) -> (Int -> a) -> Int -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BL ix a -> Int -> a
forall ix. Index ix => Array BL ix a -> Int -> a
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array BL ix a
arr)
  {-# INLINE fmap #-}
  <$ :: forall a b. a -> Array BL ix b -> Array BL ix a
(<$) a
e Array BL ix b
arr = Comp -> Sz ix -> a -> Array BL ix a
forall r ix e. Load r ix e => Comp -> Sz ix -> e -> Array r ix e
replicate (Array BL ix b -> Comp
forall r ix e. Strategy r => Array r ix e -> Comp
forall ix e. Array BL ix e -> Comp
getComp Array BL ix b
arr) (Array BL ix b -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array BL ix e -> Sz ix
size Array BL ix b
arr) a
e
  {-# INLINE (<$) #-}

instance Index ix => Traversable (Array BL ix) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array BL ix a -> f (Array BL ix b)
traverse = (a -> f b) -> Array BL ix a -> f (Array BL ix b)
forall r ix e r' a (f :: * -> *).
(Source r' a, Manifest r e, Index ix, Applicative f) =>
(a -> f e) -> Array r' ix a -> f (Array r ix e)
traverseA
  {-# INLINE traverse #-}

instance (IsList (Array L ix e), Ragged L ix e) => IsList (Array BL ix e) where
  type Item (Array BL ix e) = Item (Array L ix e)
  fromList :: [Item (Array BL ix e)] -> Array BL ix e
fromList = Comp -> [ListItem ix e] -> Array BL ix e
forall r ix e.
(HasCallStack, Ragged L ix e, Manifest r e) =>
Comp -> [ListItem ix e] -> Array r ix e
L.fromLists' Comp
Seq
  {-# INLINE fromList #-}
  toList :: Array BL ix e -> [Item (Array BL ix e)]
toList = Array L ix e -> [Item (Array L ix e)]
Array L ix e -> [ListItem ix e]
forall l. IsList l => l -> [Item l]
GHC.toList (Array L ix e -> [ListItem ix e])
-> (Array BL ix e -> Array L ix e)
-> Array BL ix e
-> [ListItem ix e]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BL ix e -> Array L ix e
forall ix e r.
(Ragged L ix e, Shape r ix, Source r e) =>
Array r ix e -> Array L ix e
toListArray
  {-# INLINE toList #-}

instance Num e => FoldNumeric BL e where
  unsafeDotProduct :: forall ix. Index ix => Array BL ix e -> Array BL ix e -> e
unsafeDotProduct = Array BL ix e -> Array BL ix e -> e
forall e ix r.
(Num e, Index ix, Source r e) =>
Array r ix e -> Array r ix e -> e
defaultUnsafeDotProduct
  {-# INLINE unsafeDotProduct #-}
  powerSumArray :: forall ix. Index ix => Array BL ix e -> Int -> e
powerSumArray = Array BL ix e -> Int -> e
forall ix r e.
(Index ix, Source r e, Num e) =>
Array r ix e -> Int -> e
defaultPowerSumArray
  {-# INLINE powerSumArray #-}
  foldArray :: forall ix. Index ix => (e -> e -> e) -> e -> Array BL ix e -> e
foldArray = (e -> e -> e) -> e -> Array BL ix e -> e
forall ix r e.
(Index ix, Source r e) =>
(e -> e -> e) -> e -> Array r ix e -> e
defaultFoldArray
  {-# INLINE foldArray #-}

instance Num e => Numeric BL e where
  unsafeLiftArray :: forall ix. Index ix => (e -> e) -> Array BL ix e -> Array BL ix e
unsafeLiftArray = (e -> e) -> Array BL ix e -> Array BL ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e) -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray
  {-# INLINE unsafeLiftArray #-}
  unsafeLiftArray2 :: forall ix.
Index ix =>
(e -> e -> e) -> Array BL ix e -> Array BL ix e -> Array BL ix e
unsafeLiftArray2 = (e -> e -> e) -> Array BL ix e -> Array BL ix e -> Array BL ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e -> e) -> Array r ix e -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray2
  {-# INLINE unsafeLiftArray2 #-}

------------------
-- Boxed Strict --
------------------

-- | Array representation for Boxed elements. Its elements are strict to Weak
-- Head Normal Form (WHNF) only.
data B = B deriving (Int -> B -> ShowS
[B] -> ShowS
B -> String
(Int -> B -> ShowS) -> (B -> String) -> ([B] -> ShowS) -> Show B
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> B -> ShowS
showsPrec :: Int -> B -> ShowS
$cshow :: B -> String
show :: B -> String
$cshowList :: [B] -> ShowS
showList :: [B] -> ShowS
Show)

newtype instance Array B ix e = BArray (Array BL ix e)

newtype instance MArray s B ix e = MBArray (MArray s BL ix e)

instance (Ragged L ix e, Show e) => Show (Array B ix e) where
  showsPrec :: Int -> Array B ix e -> ShowS
showsPrec = (Array B ix e -> Array B ix e) -> Int -> Array B ix e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec Array B ix e -> Array B ix e
forall a. a -> a
id
  showList :: [Array B ix e] -> ShowS
showList = [Array B ix e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

instance (Index ix, NFData e) => NFData (Array B ix e) where
  rnf :: Array B ix e -> ()
rnf = (Array BL ix e -> () -> ()
forall a ix t. (NFData a, Index ix) => Array BL ix a -> t -> t
`deepseqArray` ()) (Array BL ix e -> ())
-> (Array B ix e -> Array BL ix e) -> Array B ix e -> ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE rnf #-}

instance (Index ix, Eq e) => Eq (Array B ix e) where
  == :: Array B ix e -> Array B ix e -> Bool
(==) = (e -> e -> Bool) -> Array B ix e -> Array B ix e -> Bool
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool
eqArrays e -> e -> Bool
forall a. Eq a => a -> a -> Bool
(==)
  {-# INLINE (==) #-}

instance (Index ix, Ord e) => Ord (Array B ix e) where
  compare :: Array B ix e -> Array B ix e -> Ordering
compare = (e -> e -> Ordering) -> Array B ix e -> Array B ix e -> Ordering
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Ordering)
-> Array r1 ix e1 -> Array r2 ix e2 -> Ordering
compareArrays e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
  {-# INLINE compare #-}

instance Source B e where
  unsafeLinearIndex :: forall ix. Index ix => Array B ix e -> Int -> e
unsafeLinearIndex Array B ix e
arr = Array BL ix e -> Int -> e
forall ix. Index ix => Array BL ix e -> Int -> e
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex (Array B ix e -> Array BL ix e
forall ix e. Array B ix e -> Array BL ix e
toLazyArray Array B ix e
arr)
  {-# INLINE unsafeLinearIndex #-}

  unsafeLinearSlice :: forall ix. Index ix => Int -> Sz1 -> Array B ix e -> Array B Int e
unsafeLinearSlice Int
i Sz1
k Array B ix e
arr = Array BL Int e -> Array B Int e
forall a b. Coercible a b => a -> b
coerce (Int -> Sz1 -> Array BL ix e -> Array BL Int e
forall ix.
Index ix =>
Int -> Sz1 -> Array BL ix e -> Array BL Int e
forall r e ix.
(Source r e, Index ix) =>
Int -> Sz1 -> Array r ix e -> Array r Int e
unsafeLinearSlice Int
i Sz1
k (Array B ix e -> Array BL ix e
forall ix e. Array B ix e -> Array BL ix e
toLazyArray Array B ix e
arr))
  {-# INLINE unsafeLinearSlice #-}

  unsafeOuterSlice :: forall ix.
(Index ix, Index (Lower ix)) =>
Array B ix e -> Sz (Lower ix) -> Int -> Array B (Lower ix) e
unsafeOuterSlice Array B ix e
arr Sz (Lower ix)
i = (Int -> Array BL (Lower ix) e) -> Int -> Array B (Lower ix) e
forall a b. Coercible a b => a -> b
coerce (Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
forall ix.
(Index ix, Index (Lower ix)) =>
Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
forall r e ix.
(Source r e, Index ix, Index (Lower ix)) =>
Array r ix e -> Sz (Lower ix) -> Int -> Array r (Lower ix) e
unsafeOuterSlice (Array B ix e -> Array BL ix e
forall ix e. Array B ix e -> Array BL ix e
toLazyArray Array B ix e
arr) Sz (Lower ix)
i)
  {-# INLINE unsafeOuterSlice #-}

instance Strategy B where
  getComp :: forall ix e. Array B ix e -> Comp
getComp = Array BL ix e -> Comp
forall ix e. Array BL ix e -> Comp
blComp (Array BL ix e -> Comp)
-> (Array B ix e -> Array BL ix e) -> Array B ix e -> Comp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE getComp #-}
  setComp :: forall ix e. Comp -> Array B ix e -> Array B ix e
setComp Comp
c Array B ix e
arr = Array BL ix e -> Array B ix e
forall ix e. Array BL ix e -> Array B ix e
coerceBoxedArray (Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce Array B ix e
arr){blComp = c}
  {-# INLINE setComp #-}
  repr :: B
repr = B
B

instance Index ix => Shape B ix where
  maxLinearSize :: forall e. Array B ix e -> Maybe Sz1
maxLinearSize = Sz1 -> Maybe Sz1
forall a. a -> Maybe a
Just (Sz1 -> Maybe Sz1)
-> (Array B ix e -> Sz1) -> Array B ix e -> Maybe Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array B ix e -> Int) -> Array B ix e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount
  {-# INLINE maxLinearSize #-}

instance Size B where
  size :: forall ix e. Array B ix e -> Sz ix
size = Array BL ix e -> Sz ix
forall ix e. Array BL ix e -> Sz ix
blSize (Array BL ix e -> Sz ix)
-> (Array B ix e -> Array BL ix e) -> Array B ix e -> Sz ix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE size #-}
  unsafeResize :: forall ix ix' e.
(Index ix, Index ix') =>
Sz ix' -> Array B ix e -> Array B ix' e
unsafeResize Sz ix'
sz = (Array BL ix e -> Array BL ix' e) -> Array B ix e -> Array B ix' e
forall a b. Coercible a b => a -> b
coerce (\Array BL ix e
arr -> Array BL ix e
arr{blSize = sz})
  {-# INLINE unsafeResize #-}

instance Manifest B e where
  unsafeLinearIndexM :: forall ix. Index ix => Array B ix e -> Int -> e
unsafeLinearIndexM = (Array BL ix e -> Int -> e) -> Array B ix e -> Int -> e
forall a b. Coercible a b => a -> b
coerce Array BL ix e -> Int -> e
forall ix. Index ix => Array BL ix e -> Int -> e
forall r e ix. (Manifest r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndexM
  {-# INLINE unsafeLinearIndexM #-}

  sizeOfMArray :: forall ix s. Index ix => MArray s B ix e -> Sz ix
sizeOfMArray = MArray s BL ix e -> Sz ix
forall ix s. Index ix => MArray s BL ix e -> Sz ix
forall r e ix s.
(Manifest r e, Index ix) =>
MArray s r ix e -> Sz ix
sizeOfMArray (MArray s BL ix e -> Sz ix)
-> (MArray s B ix e -> MArray s BL ix e)
-> MArray s B ix e
-> Sz ix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s B ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: forall ix' ix s.
(Index ix', Index ix) =>
Sz ix' -> MArray s B ix e -> MArray s B ix' e
unsafeResizeMArray Sz ix'
sz = MArray s BL ix' e -> MArray s B ix' e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray s BL ix' e -> MArray s B ix' e)
-> (MArray s B ix e -> MArray s BL ix' e)
-> MArray s B ix e
-> MArray s B ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
forall r e ix' ix s.
(Manifest r e, Index ix', Index ix) =>
Sz ix' -> MArray s r ix e -> MArray s r ix' e
forall ix' ix s.
(Index ix', Index ix) =>
Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
unsafeResizeMArray Sz ix'
sz (MArray s BL ix e -> MArray s BL ix' e)
-> (MArray s B ix e -> MArray s BL ix e)
-> MArray s B ix e
-> MArray s BL ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s B ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: forall ix s.
Index ix =>
Int -> Sz1 -> MArray s B ix e -> MVector s B e
unsafeLinearSliceMArray Int
i Sz1
k = MArray s BL Int e -> MArray s B Int e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray s BL Int e -> MArray s B Int e)
-> (MArray s B ix e -> MArray s BL Int e)
-> MArray s B ix e
-> MArray s B Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1 -> MArray s BL ix e -> MArray s BL Int e
forall ix s.
Index ix =>
Int -> Sz1 -> MArray s BL ix e -> MVector s BL e
forall r e ix s.
(Manifest r e, Index ix) =>
Int -> Sz1 -> MArray s r ix e -> MVector s r e
unsafeLinearSliceMArray Int
i Sz1
k (MArray s BL ix e -> MArray s BL Int e)
-> (MArray s B ix e -> MArray s BL ix e)
-> MArray s B ix e
-> MArray s BL Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s B ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Array B ix e -> m (MArray (PrimState m) B ix e)
unsafeThaw Array B ix e
arr = MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) B ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array BL ix e -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Array r ix e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Array BL ix e -> m (MArray (PrimState m) BL ix e)
unsafeThaw (Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce Array B ix e
arr)
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) B ix e -> m (Array B ix e)
unsafeFreeze Comp
comp MArray (PrimState m) B ix e
marr = Array BL ix e -> Array B ix e
forall ix e. Array BL ix e -> Array B ix e
BArray (Array BL ix e -> Array B ix e)
-> m (Array BL ix e) -> m (Array B ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
unsafeFreeze Comp
comp (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) B ix e
marr)
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) B ix e)
unsafeNew Sz ix
sz = MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) B ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sz ix -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) BL ix e)
unsafeNew Sz ix
sz
  {-# INLINE unsafeNew #-}

  initialize :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) B ix e -> m ()
initialize MArray (PrimState m) B ix e
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  {-# INLINE initialize #-}

  newMArray :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) B ix e)
newMArray Sz ix
sz !e
e = MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) B ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) B ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sz ix -> e -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BL ix e)
newMArray Sz ix
sz e
e
  {-# INLINE newMArray #-}

  unsafeLinearRead :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) B ix e -> Int -> m e
unsafeLinearRead MArray (PrimState m) B ix e
ma = MArray (PrimState m) BL ix e -> Int -> m e
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
MArray (PrimState m) r ix e -> Int -> m e
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> m e
unsafeLinearRead (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) B ix e
ma)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) B ix e -> Int -> e -> m ()
unsafeLinearWrite MArray (PrimState m) B ix e
ma Int
i e
e = e
e e -> m () -> m ()
forall a b. a -> b -> b
`seq` MArray (PrimState m) BL ix e -> Int -> e -> m ()
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
MArray (PrimState m) r ix e -> Int -> e -> m ()
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> e -> m ()
unsafeLinearWrite (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) B ix e
ma) Int
i e
e
  {-# INLINE unsafeLinearWrite #-}

instance Index ix => Load B ix e where
  makeArray :: Comp -> Sz ix -> (ix -> e) -> Array B ix e
makeArray Comp
comp Sz ix
sz ix -> e
f = Array D ix e -> Array B ix e
forall r ix e r'.
(Manifest r e, Load r' ix e) =>
Array r' ix e -> Array r ix e
compute (Comp -> Sz ix -> (ix -> e) -> Array D ix e
forall r ix e.
Load r ix e =>
Comp -> Sz ix -> (ix -> e) -> Array r ix e
makeArray Comp
comp Sz ix
sz ix -> e
f :: Array D ix e)
  {-# INLINE makeArray #-}

  makeArrayLinear :: Comp -> Sz ix -> (Int -> e) -> Array B ix e
makeArrayLinear !Comp
comp !Sz ix
sz Int -> e
f = IO (Array B ix e) -> Array B ix e
forall a. IO a -> a
unsafePerformIO (IO (Array B ix e) -> Array B ix e)
-> IO (Array B ix e) -> Array B ix e
forall a b. (a -> b) -> a -> b
$ Comp -> Sz ix -> (Int -> IO e) -> IO (Array B ix e)
forall r ix e (m :: * -> *).
(MonadUnliftIO m, Manifest r e, Index ix) =>
Comp -> Sz ix -> (Int -> m e) -> m (Array r ix e)
generateArrayLinear Comp
comp Sz ix
sz (e -> IO e
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> IO e) -> (Int -> e) -> Int -> IO e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> e
f)
  {-# INLINE makeArrayLinear #-}

  replicate :: Comp -> Sz ix -> e -> Array B ix e
replicate Comp
comp Sz ix
sz e
e = (forall s. ST s (Array B ix e)) -> Array B ix e
forall a. (forall s. ST s a) -> a
runST (Sz ix -> e -> ST s (MArray (PrimState (ST s)) B ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) B ix e)
newMArray Sz ix
sz e
e ST s (MArray s B ix e)
-> (MArray s B ix e -> ST s (Array B ix e)) -> ST s (Array B ix e)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Comp -> MArray (PrimState (ST s)) B ix e -> ST s (Array B ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) B ix e -> m (Array B ix e)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}

  iterArrayLinearST_ :: forall s.
Scheduler s () -> Array B ix e -> (Int -> e -> ST s ()) -> ST s ()
iterArrayLinearST_ Scheduler s ()
scheduler = (Array BL ix e -> (Int -> e -> ST s ()) -> ST s ())
-> Array B ix e -> (Int -> e -> ST s ()) -> ST s ()
forall a b. Coercible a b => a -> b
coerce (Scheduler s () -> Array BL ix e -> (Int -> e -> ST s ()) -> ST s ()
forall s.
Scheduler s () -> Array BL ix e -> (Int -> e -> ST s ()) -> ST s ()
forall r ix e s.
Load r ix e =>
Scheduler s () -> Array r ix e -> (Int -> e -> ST s ()) -> ST s ()
iterArrayLinearST_ Scheduler s ()
scheduler)
  {-# INLINE iterArrayLinearST_ #-}

instance Index ix => StrideLoad B ix e

instance Index ix => Stream B ix e where
  toStream :: Array B ix e -> Steps Id e
toStream = Array B ix e -> Steps Id e
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m e
S.steps
  {-# INLINE toStream #-}
  toStreamIx :: Array B ix e -> Steps Id (ix, e)
toStreamIx = Array B ix e -> Steps Id (ix, e)
forall r ix e (m :: * -> *).
(Monad m, Index ix, Source r e) =>
Array r ix e -> Steps m (ix, e)
S.isteps
  {-# INLINE toStreamIx #-}

-- | Row-major sequential folding over a Boxed array.
instance Index ix => Foldable (Array B ix) where
  fold :: forall m. Monoid m => Array B ix m -> m
fold = Array B ix m -> m
forall e ix r.
(Monoid e, Index ix, Source r e) =>
Array r ix e -> e
fold
  {-# INLINE fold #-}
  foldMap :: forall m a. Monoid m => (a -> m) -> Array B ix a -> m
foldMap = (a -> m) -> Array B ix a -> m
forall ix r e m.
(Index ix, Source r e, Monoid m) =>
(e -> m) -> Array r ix e -> m
foldMono
  {-# INLINE foldMap #-}
  foldl :: forall b a. (b -> a -> b) -> b -> Array B ix a -> b
foldl = (b -> a -> b) -> b -> Array B ix a -> b
forall ix r e a.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> Array r ix e -> a
lazyFoldlS
  {-# INLINE foldl #-}
  foldl' :: forall b a. (b -> a -> b) -> b -> Array B ix a -> b
foldl' = (b -> a -> b) -> b -> Array B ix a -> b
forall ix r e a.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> Array r ix e -> a
foldlS
  {-# INLINE foldl' #-}
  foldr :: forall a b. (a -> b -> b) -> b -> Array B ix a -> b
foldr = (a -> b -> b) -> b -> Array B ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrFB
  {-# INLINE foldr #-}
  foldr' :: forall a b. (a -> b -> b) -> b -> Array B ix a -> b
foldr' = (a -> b -> b) -> b -> Array B ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrS
  {-# INLINE foldr' #-}
  null :: forall a. Array B ix a -> Bool
null Array B ix a
arr = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem (Array B ix a -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array B ix e -> Sz ix
size Array B ix a
arr) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
  {-# INLINE null #-}
  length :: forall a. Array B ix a -> Int
length = Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem (Sz ix -> Int) -> (Array B ix a -> Sz ix) -> Array B ix a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix a -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array B ix e -> Sz ix
size
  {-# INLINE length #-}
  toList :: forall a. Array B ix a -> [a]
toList Array B ix a
arr = (forall b. (a -> b -> b) -> b -> b) -> [a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\a -> b -> b
c b
n -> (a -> b -> b) -> b -> Array B ix a -> b
forall ix r e b.
(Index ix, Source r e) =>
(e -> b -> b) -> b -> Array r ix e -> b
foldrFB a -> b -> b
c b
n Array B ix a
arr)
  {-# INLINE toList #-}

instance Index ix => Functor (Array B ix) where
  fmap :: forall a b. (a -> b) -> Array B ix a -> Array B ix b
fmap a -> b
f Array B ix a
arr = Comp -> Sz ix -> (Int -> b) -> Array B ix b
forall r ix e.
Load r ix e =>
Comp -> Sz ix -> (Int -> e) -> Array r ix e
makeArrayLinear (Array B ix a -> Comp
forall r ix e. Strategy r => Array r ix e -> Comp
forall ix e. Array B ix e -> Comp
getComp Array B ix a
arr) (Array B ix a -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array B ix e -> Sz ix
size Array B ix a
arr) (a -> b
f (a -> b) -> (Int -> a) -> Int -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix a -> Int -> a
forall ix. Index ix => Array B ix a -> Int -> a
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array B ix a
arr)
  {-# INLINE fmap #-}
  <$ :: forall a b. a -> Array B ix b -> Array B ix a
(<$) !a
e Array B ix b
arr = Comp -> Sz ix -> a -> Array B ix a
forall r ix e. Load r ix e => Comp -> Sz ix -> e -> Array r ix e
replicate (Array B ix b -> Comp
forall r ix e. Strategy r => Array r ix e -> Comp
forall ix e. Array B ix e -> Comp
getComp Array B ix b
arr) (Array B ix b -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
forall ix e. Array B ix e -> Sz ix
size Array B ix b
arr) a
e
  {-# INLINE (<$) #-}

instance Index ix => Traversable (Array B ix) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Array B ix a -> f (Array B ix b)
traverse = (a -> f b) -> Array B ix a -> f (Array B ix b)
forall r ix e r' a (f :: * -> *).
(Source r' a, Manifest r e, Index ix, Applicative f) =>
(a -> f e) -> Array r' ix a -> f (Array r ix e)
traverseA
  {-# INLINE traverse #-}

instance (IsList (Array L ix e), Ragged L ix e) => IsList (Array B ix e) where
  type Item (Array B ix e) = Item (Array L ix e)
  fromList :: [Item (Array B ix e)] -> Array B ix e
fromList = Comp -> [ListItem ix e] -> Array B ix e
forall r ix e.
(HasCallStack, Ragged L ix e, Manifest r e) =>
Comp -> [ListItem ix e] -> Array r ix e
L.fromLists' Comp
Seq
  {-# INLINE fromList #-}
  toList :: Array B ix e -> [Item (Array B ix e)]
toList = Array L ix e -> [Item (Array L ix e)]
Array L ix e -> [ListItem ix e]
forall l. IsList l => l -> [Item l]
GHC.toList (Array L ix e -> [ListItem ix e])
-> (Array B ix e -> Array L ix e)
-> Array B ix e
-> [ListItem ix e]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Array L ix e
forall ix e r.
(Ragged L ix e, Shape r ix, Source r e) =>
Array r ix e -> Array L ix e
toListArray
  {-# INLINE toList #-}

instance Num e => FoldNumeric B e where
  unsafeDotProduct :: forall ix. Index ix => Array B ix e -> Array B ix e -> e
unsafeDotProduct = Array B ix e -> Array B ix e -> e
forall e ix r.
(Num e, Index ix, Source r e) =>
Array r ix e -> Array r ix e -> e
defaultUnsafeDotProduct
  {-# INLINE unsafeDotProduct #-}
  powerSumArray :: forall ix. Index ix => Array B ix e -> Int -> e
powerSumArray = Array B ix e -> Int -> e
forall ix r e.
(Index ix, Source r e, Num e) =>
Array r ix e -> Int -> e
defaultPowerSumArray
  {-# INLINE powerSumArray #-}
  foldArray :: forall ix. Index ix => (e -> e -> e) -> e -> Array B ix e -> e
foldArray = (e -> e -> e) -> e -> Array B ix e -> e
forall ix r e.
(Index ix, Source r e) =>
(e -> e -> e) -> e -> Array r ix e -> e
defaultFoldArray
  {-# INLINE foldArray #-}

instance Num e => Numeric B e where
  unsafeLiftArray :: forall ix. Index ix => (e -> e) -> Array B ix e -> Array B ix e
unsafeLiftArray = (e -> e) -> Array B ix e -> Array B ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e) -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray
  {-# INLINE unsafeLiftArray #-}
  unsafeLiftArray2 :: forall ix.
Index ix =>
(e -> e -> e) -> Array B ix e -> Array B ix e -> Array B ix e
unsafeLiftArray2 = (e -> e -> e) -> Array B ix e -> Array B ix e -> Array B ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e -> e) -> Array r ix e -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray2
  {-# INLINE unsafeLiftArray2 #-}

-----------------------
-- Boxed Normal Form --
-----------------------

-- | Array representation for Boxed elements. Its elements are always in Normal
-- Form (NF), therefore `NFData` instance is required.
data BN = BN deriving (Int -> BN -> ShowS
[BN] -> ShowS
BN -> String
(Int -> BN -> ShowS)
-> (BN -> String) -> ([BN] -> ShowS) -> Show BN
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BN -> ShowS
showsPrec :: Int -> BN -> ShowS
$cshow :: BN -> String
show :: BN -> String
$cshowList :: [BN] -> ShowS
showList :: [BN] -> ShowS
Show)

-- | Type and pattern `N` have been added for backwards compatibility and will be replaced
-- in the future in favor of `BN`.
--
-- /Deprecated/ - since 1.0.0
type N = BN

pattern N :: N
pattern $mN :: forall {r}. BN -> ((# #) -> r) -> ((# #) -> r) -> r
$bN :: BN
N = BN

{-# COMPLETE N #-}

{-# DEPRECATED N "In favor of more consistently named `BN`" #-}

newtype instance Array BN ix e = BNArray (Array BL ix e)

newtype instance MArray s BN ix e = MBNArray (MArray s BL ix e)

instance (Ragged L ix e, Show e, NFData e) => Show (Array BN ix e) where
  showsPrec :: Int -> Array BN ix e -> ShowS
showsPrec = (Array BN ix e -> Array BL ix e) -> Int -> Array BN ix e -> ShowS
forall r r' ix e.
(Ragged L ix e, Load r ix e, Load r' ix e, Source r' e, Show e) =>
(Array r ix e -> Array r' ix e) -> Int -> Array r ix e -> ShowS
showsArrayPrec Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  showList :: [Array BN ix e] -> ShowS
showList = [Array BN ix e] -> ShowS
forall arr. Show arr => [arr] -> ShowS
showArrayList

-- | /O(1)/ - `BN` is already in normal form
instance NFData (Array BN ix e) where
  rnf :: Array BN ix e -> ()
rnf = (Array BN ix e -> () -> ()
forall a b. a -> b -> b
`seq` ())
  {-# INLINE rnf #-}

instance (Index ix, NFData e, Eq e) => Eq (Array BN ix e) where
  == :: Array BN ix e -> Array BN ix e -> Bool
(==) = (e -> e -> Bool) -> Array BN ix e -> Array BN ix e -> Bool
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Bool) -> Array r1 ix e1 -> Array r2 ix e2 -> Bool
eqArrays e -> e -> Bool
forall a. Eq a => a -> a -> Bool
(==)
  {-# INLINE (==) #-}

instance (Index ix, NFData e, Ord e) => Ord (Array BN ix e) where
  compare :: Array BN ix e -> Array BN ix e -> Ordering
compare = (e -> e -> Ordering) -> Array BN ix e -> Array BN ix e -> Ordering
forall ix r1 e1 r2 e2.
(Index ix, Source r1 e1, Source r2 e2) =>
(e1 -> e2 -> Ordering)
-> Array r1 ix e1 -> Array r2 ix e2 -> Ordering
compareArrays e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
  {-# INLINE compare #-}

instance Strategy BN where
  setComp :: forall ix e. Comp -> Array BN ix e -> Array BN ix e
setComp Comp
c = (Array BL ix e -> Array BL ix e) -> Array BN ix e -> Array BN ix e
forall a b. Coercible a b => a -> b
coerce (Comp -> Array BL ix e -> Array BL ix e
forall r ix e. Strategy r => Comp -> Array r ix e -> Array r ix e
forall ix e. Comp -> Array BL ix e -> Array BL ix e
setComp Comp
c)
  {-# INLINE setComp #-}
  getComp :: forall ix e. Array BN ix e -> Comp
getComp = Array BL ix e -> Comp
forall ix e. Array BL ix e -> Comp
blComp (Array BL ix e -> Comp)
-> (Array BN ix e -> Array BL ix e) -> Array BN ix e -> Comp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE getComp #-}
  repr :: BN
repr = BN
BN

instance NFData e => Source BN e where
  unsafeLinearIndex :: forall ix. Index ix => Array BN ix e -> Int -> e
unsafeLinearIndex (BNArray Array BL ix e
arr) = Array BL ix e -> Int -> e
forall ix. Index ix => Array BL ix e -> Int -> e
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array BL ix e
arr
  {-# INLINE unsafeLinearIndex #-}
  unsafeLinearSlice :: forall ix.
Index ix =>
Int -> Sz1 -> Array BN ix e -> Array BN Int e
unsafeLinearSlice Int
i Sz1
k (BNArray Array BL ix e
a) = Array BL Int e -> Array BN Int e
forall a b. Coercible a b => a -> b
coerce (Int -> Sz1 -> Array BL ix e -> Array BL Int e
forall ix.
Index ix =>
Int -> Sz1 -> Array BL ix e -> Array BL Int e
forall r e ix.
(Source r e, Index ix) =>
Int -> Sz1 -> Array r ix e -> Array r Int e
unsafeLinearSlice Int
i Sz1
k Array BL ix e
a)
  {-# INLINE unsafeLinearSlice #-}
  unsafeOuterSlice :: forall ix.
(Index ix, Index (Lower ix)) =>
Array BN ix e -> Sz (Lower ix) -> Int -> Array BN (Lower ix) e
unsafeOuterSlice (BNArray Array BL ix e
a) Sz (Lower ix)
i = (Int -> Array BL (Lower ix) e) -> Int -> Array BN (Lower ix) e
forall a b. Coercible a b => a -> b
coerce (Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
forall ix.
(Index ix, Index (Lower ix)) =>
Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
forall r e ix.
(Source r e, Index ix, Index (Lower ix)) =>
Array r ix e -> Sz (Lower ix) -> Int -> Array r (Lower ix) e
unsafeOuterSlice Array BL ix e
a Sz (Lower ix)
i)
  {-# INLINE unsafeOuterSlice #-}

instance Index ix => Shape BN ix where
  maxLinearSize :: forall e. Array BN ix e -> Maybe Sz1
maxLinearSize = Sz1 -> Maybe Sz1
forall a. a -> Maybe a
Just (Sz1 -> Maybe Sz1)
-> (Array BN ix e -> Sz1) -> Array BN ix e -> Maybe Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Int -> Sz1) -> (Array BN ix e -> Int) -> Array BN ix e -> Sz1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount
  {-# INLINE maxLinearSize #-}

instance Size BN where
  size :: forall ix e. Array BN ix e -> Sz ix
size = Array BL ix e -> Sz ix
forall ix e. Array BL ix e -> Sz ix
blSize (Array BL ix e -> Sz ix)
-> (Array BN ix e -> Array BL ix e) -> Array BN ix e -> Sz ix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE size #-}

  unsafeResize :: forall ix ix' e.
(Index ix, Index ix') =>
Sz ix' -> Array BN ix e -> Array BN ix' e
unsafeResize !Sz ix'
sz = Array BL ix' e -> Array BN ix' e
forall a b. Coercible a b => a -> b
coerce (Array BL ix' e -> Array BN ix' e)
-> (Array BN ix e -> Array BL ix' e)
-> Array BN ix e
-> Array BN ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sz ix' -> Array BL ix e -> Array BL ix' e
forall r ix ix' e.
(Size r, Index ix, Index ix') =>
Sz ix' -> Array r ix e -> Array r ix' e
forall ix ix' e.
(Index ix, Index ix') =>
Sz ix' -> Array BL ix e -> Array BL ix' e
unsafeResize Sz ix'
sz (Array BL ix e -> Array BL ix' e)
-> (Array BN ix e -> Array BL ix e)
-> Array BN ix e
-> Array BL ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE unsafeResize #-}

instance NFData e => Manifest BN e where
  unsafeLinearIndexM :: forall ix. Index ix => Array BN ix e -> Int -> e
unsafeLinearIndexM Array BN ix e
arr = Array BL ix e -> Int -> e
forall ix. Index ix => Array BL ix e -> Int -> e
forall r e ix. (Manifest r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndexM (Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce Array BN ix e
arr)
  {-# INLINE unsafeLinearIndexM #-}

  sizeOfMArray :: forall ix s. Index ix => MArray s BN ix e -> Sz ix
sizeOfMArray = MArray s BL ix e -> Sz ix
forall ix s. Index ix => MArray s BL ix e -> Sz ix
forall r e ix s.
(Manifest r e, Index ix) =>
MArray s r ix e -> Sz ix
sizeOfMArray (MArray s BL ix e -> Sz ix)
-> (MArray s BN ix e -> MArray s BL ix e)
-> MArray s BN ix e
-> Sz ix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s BN ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: forall ix' ix s.
(Index ix', Index ix) =>
Sz ix' -> MArray s BN ix e -> MArray s BN ix' e
unsafeResizeMArray Sz ix'
sz = MArray s BL ix' e -> MArray s BN ix' e
forall a b. Coercible a b => a -> b
coerce (MArray s BL ix' e -> MArray s BN ix' e)
-> (MArray s BN ix e -> MArray s BL ix' e)
-> MArray s BN ix e
-> MArray s BN ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
forall r e ix' ix s.
(Manifest r e, Index ix', Index ix) =>
Sz ix' -> MArray s r ix e -> MArray s r ix' e
forall ix' ix s.
(Index ix', Index ix) =>
Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
unsafeResizeMArray Sz ix'
sz (MArray s BL ix e -> MArray s BL ix' e)
-> (MArray s BN ix e -> MArray s BL ix e)
-> MArray s BN ix e
-> MArray s BL ix' e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s BN ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: forall ix s.
Index ix =>
Int -> Sz1 -> MArray s BN ix e -> MVector s BN e
unsafeLinearSliceMArray Int
i Sz1
k = MArray s BL Int e -> MArray s BN Int e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray s BL Int e -> MArray s BN Int e)
-> (MArray s BN ix e -> MArray s BL Int e)
-> MArray s BN ix e
-> MArray s BN Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1 -> MArray s BL ix e -> MArray s BL Int e
forall ix s.
Index ix =>
Int -> Sz1 -> MArray s BL ix e -> MVector s BL e
forall r e ix s.
(Manifest r e, Index ix) =>
Int -> Sz1 -> MArray s r ix e -> MVector s r e
unsafeLinearSliceMArray Int
i Sz1
k (MArray s BL ix e -> MArray s BL Int e)
-> (MArray s BN ix e -> MArray s BL ix e)
-> MArray s BN ix e
-> MArray s BL Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s BN ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Array BN ix e -> m (MArray (PrimState m) BN ix e)
unsafeThaw Array BN ix e
arr = MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) BN ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array BL ix e -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Array r ix e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Array BL ix e -> m (MArray (PrimState m) BL ix e)
unsafeThaw (Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce Array BN ix e
arr)
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BN ix e -> m (Array BN ix e)
unsafeFreeze Comp
comp MArray (PrimState m) BN ix e
marr = Array BL ix e -> Array BN ix e
forall ix e. Array BL ix e -> Array BN ix e
BNArray (Array BL ix e -> Array BN ix e)
-> m (Array BL ix e) -> m (Array BN ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
unsafeFreeze Comp
comp (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) BN ix e
marr)
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) BN ix e)
unsafeNew Sz ix
sz = MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) BN ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sz ix -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> m (MArray (PrimState m) BL ix e)
unsafeNew Sz ix
sz
  {-# INLINE unsafeNew #-}

  initialize :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BN ix e -> m ()
initialize MArray (PrimState m) BN ix e
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  {-# INLINE initialize #-}

  newMArray :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BN ix e)
newMArray Sz ix
sz e
e = e
e e
-> m (MArray (PrimState m) BN ix e)
-> m (MArray (PrimState m) BN ix e)
forall a b. NFData a => a -> b -> b
`deepseq` (MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray (PrimState m) BL ix e -> MArray (PrimState m) BN ix e)
-> m (MArray (PrimState m) BL ix e)
-> m (MArray (PrimState m) BN ix e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sz ix -> e -> m (MArray (PrimState m) BL ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BL ix e)
newMArray Sz ix
sz e
e)
  {-# INLINE newMArray #-}

  unsafeLinearRead :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BN ix e -> Int -> m e
unsafeLinearRead MArray (PrimState m) BN ix e
ma = MArray (PrimState m) BL ix e -> Int -> m e
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
MArray (PrimState m) r ix e -> Int -> m e
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> m e
unsafeLinearRead (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) BN ix e
ma)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BN ix e -> Int -> e -> m ()
unsafeLinearWrite MArray (PrimState m) BN ix e
ma Int
i e
e = e
e e -> m () -> m ()
forall a b. NFData a => a -> b -> b
`deepseq` MArray (PrimState m) BL ix e -> Int -> e -> m ()
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
MArray (PrimState m) r ix e -> Int -> e -> m ()
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
MArray (PrimState m) BL ix e -> Int -> e -> m ()
unsafeLinearWrite (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
forall a b. Coercible a b => a -> b
coerce MArray (PrimState m) BN ix e
ma) Int
i e
e
  {-# INLINE unsafeLinearWrite #-}

instance (Index ix, NFData e) => Load BN ix e where
  makeArray :: Comp -> Sz ix -> (ix -> e) -> Array BN ix e
makeArray Comp
comp Sz ix
sz ix -> e
f = Array D ix e -> Array BN ix e
forall r ix e r'.
(Manifest r e, Load r' ix e) =>
Array r' ix e -> Array r ix e
compute (Comp -> Sz ix -> (ix -> e) -> Array D ix e
forall r ix e.
Load r ix e =>
Comp -> Sz ix -> (ix -> e) -> Array r ix e
makeArray Comp
comp Sz ix
sz ix -> e
f :: Array D ix e)
  {-# INLINE makeArray #-}
  makeArrayLinear :: Comp -> Sz ix -> (Int -> e) -> Array BN ix e
makeArrayLinear !Comp
comp !Sz ix
sz Int -> e
f = IO (Array BN ix e) -> Array BN ix e
forall a. IO a -> a
unsafePerformIO (IO (Array BN ix e) -> Array BN ix e)
-> IO (Array BN ix e) -> Array BN ix e
forall a b. (a -> b) -> a -> b
$ Comp -> Sz ix -> (Int -> IO e) -> IO (Array BN ix e)
forall r ix e (m :: * -> *).
(MonadUnliftIO m, Manifest r e, Index ix) =>
Comp -> Sz ix -> (Int -> m e) -> m (Array r ix e)
generateArrayLinear Comp
comp Sz ix
sz (e -> IO e
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (e -> IO e) -> (Int -> e) -> Int -> IO e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> e
f)
  {-# INLINE makeArrayLinear #-}
  replicate :: Comp -> Sz ix -> e -> Array BN ix e
replicate Comp
comp Sz ix
sz e
e = (forall s. ST s (Array BN ix e)) -> Array BN ix e
forall a. (forall s. ST s a) -> a
runST (Sz ix -> e -> ST s (MArray (PrimState (ST s)) BN ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Sz ix -> e -> m (MArray (PrimState m) BN ix e)
newMArray Sz ix
sz e
e ST s (MArray s BN ix e)
-> (MArray s BN ix e -> ST s (Array BN ix e))
-> ST s (Array BN ix e)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Comp -> MArray (PrimState (ST s)) BN ix e -> ST s (Array BN ix e)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BN ix e -> m (Array BN ix e)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}
  iterArrayLinearST_ :: forall s.
Scheduler s () -> Array BN ix e -> (Int -> e -> ST s ()) -> ST s ()
iterArrayLinearST_ !Scheduler s ()
scheduler !Array BN ix e
arr =
    Scheduler s ()
-> Int -> (Int -> e) -> (Int -> e -> ST s ()) -> ST s ()
forall s (m :: * -> *) b.
MonadPrimBase s m =>
Scheduler s () -> Int -> (Int -> b) -> (Int -> b -> m ()) -> m ()
splitLinearlyWith_ Scheduler s ()
scheduler (Array BN ix e -> Int
forall ix r e. (Index ix, Size r) => Array r ix e -> Int
elemsCount Array BN ix e
arr) (Array BN ix e -> Int -> e
forall ix. Index ix => Array BN ix e -> Int -> e
forall r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array BN ix e
arr)
  {-# INLINE iterArrayLinearST_ #-}

instance (Index ix, NFData e) => StrideLoad BN ix e

instance (Index ix, NFData e) => Stream BN ix e where
  toStream :: Array BN ix e -> Steps Id e
toStream = Array BL ix e -> Steps Id e
forall r ix e. Stream r ix e => Array r ix e -> Steps Id e
toStream (Array BL ix e -> Steps Id e)
-> (Array BN ix e -> Array BL ix e) -> Array BN ix e -> Steps Id e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE toStream #-}
  toStreamIx :: Array BN ix e -> Steps Id (ix, e)
toStreamIx = Array BL ix e -> Steps Id (ix, e)
forall r ix e. Stream r ix e => Array r ix e -> Steps Id (ix, e)
toStreamIx (Array BL ix e -> Steps Id (ix, e))
-> (Array BN ix e -> Array BL ix e)
-> Array BN ix e
-> Steps Id (ix, e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
  {-# INLINE toStreamIx #-}

instance (NFData e, IsList (Array L ix e), Ragged L ix e) => IsList (Array BN ix e) where
  type Item (Array BN ix e) = Item (Array L ix e)
  fromList :: [Item (Array BN ix e)] -> Array BN ix e
fromList = Comp -> [ListItem ix e] -> Array BN ix e
forall r ix e.
(HasCallStack, Ragged L ix e, Manifest r e) =>
Comp -> [ListItem ix e] -> Array r ix e
L.fromLists' Comp
Seq
  {-# INLINE fromList #-}
  toList :: Array BN ix e -> [Item (Array BN ix e)]
toList = Array L ix e -> [Item (Array L ix e)]
Array L ix e -> [ListItem ix e]
forall l. IsList l => l -> [Item l]
GHC.toList (Array L ix e -> [ListItem ix e])
-> (Array BN ix e -> Array L ix e)
-> Array BN ix e
-> [ListItem ix e]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array L ix e
forall ix e r.
(Ragged L ix e, Shape r ix, Source r e) =>
Array r ix e -> Array L ix e
toListArray
  {-# INLINE toList #-}

instance (NFData e, Num e) => FoldNumeric BN e where
  unsafeDotProduct :: forall ix. Index ix => Array BN ix e -> Array BN ix e -> e
unsafeDotProduct = Array BN ix e -> Array BN ix e -> e
forall e ix r.
(Num e, Index ix, Source r e) =>
Array r ix e -> Array r ix e -> e
defaultUnsafeDotProduct
  {-# INLINE unsafeDotProduct #-}
  powerSumArray :: forall ix. Index ix => Array BN ix e -> Int -> e
powerSumArray = Array BN ix e -> Int -> e
forall ix r e.
(Index ix, Source r e, Num e) =>
Array r ix e -> Int -> e
defaultPowerSumArray
  {-# INLINE powerSumArray #-}
  foldArray :: forall ix. Index ix => (e -> e -> e) -> e -> Array BN ix e -> e
foldArray = (e -> e -> e) -> e -> Array BN ix e -> e
forall ix r e.
(Index ix, Source r e) =>
(e -> e -> e) -> e -> Array r ix e -> e
defaultFoldArray
  {-# INLINE foldArray #-}

instance (NFData e, Num e) => Numeric BN e where
  unsafeLiftArray :: forall ix. Index ix => (e -> e) -> Array BN ix e -> Array BN ix e
unsafeLiftArray = (e -> e) -> Array BN ix e -> Array BN ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e) -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray
  {-# INLINE unsafeLiftArray #-}
  unsafeLiftArray2 :: forall ix.
Index ix =>
(e -> e -> e) -> Array BN ix e -> Array BN ix e -> Array BN ix e
unsafeLiftArray2 = (e -> e -> e) -> Array BN ix e -> Array BN ix e -> Array BN ix e
forall r ix e.
(Load r ix e, Source r e) =>
(e -> e -> e) -> Array r ix e -> Array r ix e -> Array r ix e
defaultUnsafeLiftArray2
  {-# INLINE unsafeLiftArray2 #-}

----------------------
-- Helper functions --
----------------------

uninitialized :: a
uninitialized :: forall a. a
uninitialized = Uninitialized -> a
forall a e. Exception e => e -> a
throw Uninitialized
Uninitialized

---------------------
-- WHNF conversion --
---------------------

-- | /O(1)/ - Unwrap boxed array. This will discard any possible slicing that has been
-- applied to the array.
--
-- @since 0.2.1
unwrapArray :: Array B ix e -> A.Array e
unwrapArray :: forall ix e. Array B ix e -> Array e
unwrapArray = Array BL ix e -> Array e
forall ix e. Array BL ix e -> Array e
blData (Array BL ix e -> Array e)
-> (Array B ix e -> Array BL ix e) -> Array B ix e -> Array e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unwrapArray #-}

-- | /O(n)/ - Wrap a boxed array and evaluate all elements to a WHNF.
--
-- @since 0.2.1
evalArray
  :: Comp
  -- ^ Computation strategy
  -> A.Array e
  -- ^ Lazy boxed array from @primitive@ package.
  -> Vector B e
evalArray :: forall e. Comp -> Array e -> Vector B e
evalArray Comp
comp Array e
a = Array BL Int e -> Array B Int e
forall ix e. Index ix => Array BL ix e -> Array B ix e
evalLazyArray (Array BL Int e -> Array B Int e)
-> Array BL Int e -> Array B Int e
forall a b. (a -> b) -> a -> b
$ Comp -> Array BL Int e -> Array BL Int e
forall r ix e. Strategy r => Comp -> Array r ix e -> Array r ix e
forall ix e. Comp -> Array BL ix e -> Array BL ix e
setComp Comp
comp (Array BL Int e -> Array BL Int e)
-> Array BL Int e -> Array BL Int e
forall a b. (a -> b) -> a -> b
$ Array e -> Array BL Int e
forall e. Array e -> Vector BL e
wrapLazyArray Array e
a
{-# INLINE evalArray #-}

-- | /O(1)/ - Unwrap boxed array. This will discard any possible slicing that has been
-- applied to the array.
--
-- @since 0.6.0
unwrapLazyArray :: Array BL ix e -> A.Array e
unwrapLazyArray :: forall ix e. Array BL ix e -> Array e
unwrapLazyArray = Array BL ix e -> Array e
forall ix e. Array BL ix e -> Array e
blData
{-# INLINE unwrapLazyArray #-}

-- | /O(1)/ - Wrap a boxed array.
--
-- @since 0.6.0
wrapLazyArray :: A.Array e -> Vector BL e
wrapLazyArray :: forall e. Array e -> Vector BL e
wrapLazyArray Array e
a = Comp -> Sz1 -> Int -> Array e -> Array BL Int e
forall ix e. Comp -> Sz ix -> Int -> Array e -> Array BL ix e
BLArray Comp
Seq (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz (Array e -> Int
forall a. Array a -> Int
A.sizeofArray Array e
a)) Int
0 Array e
a
{-# INLINE wrapLazyArray #-}

-- | /O(1)/ - Cast a strict boxed array into a lazy boxed array.
--
-- @since 0.6.0
toLazyArray :: Array B ix e -> Array BL ix e
toLazyArray :: forall ix e. Array B ix e -> Array BL ix e
toLazyArray = Array B ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE toLazyArray #-}

-- | /O(n)/ - Evaluate all elements of a boxed lazy array to weak head normal form
--
-- @since 0.6.0
evalLazyArray :: Index ix => Array BL ix e -> Array B ix e
evalLazyArray :: forall ix e. Index ix => Array BL ix e -> Array B ix e
evalLazyArray Array BL ix e
arr = Array BL ix e
arr Array BL ix e -> Array B ix e -> Array B ix e
forall ix a t. Index ix => Array BL ix a -> t -> t
`seqArray` Array BL ix e -> Array B ix e
forall ix e. Array BL ix e -> Array B ix e
BArray Array BL ix e
arr
{-# INLINE evalLazyArray #-}

-- | /O(n)/ - Evaluate all elements of a boxed lazy array to normal form
--
-- @since 0.6.0
forceLazyArray :: (NFData e, Index ix) => Array BL ix e -> Array N ix e
forceLazyArray :: forall e ix. (NFData e, Index ix) => Array BL ix e -> Array BN ix e
forceLazyArray Array BL ix e
arr = Array BL ix e
arr Array BL ix e -> Array BN ix e -> Array BN ix e
forall a ix t. (NFData a, Index ix) => Array BL ix a -> t -> t
`deepseqArray` Array BL ix e -> Array BN ix e
forall ix e. Array BL ix e -> Array BN ix e
BNArray Array BL ix e
arr
{-# INLINE forceLazyArray #-}

-- | /O(1)/ - Unwrap mutable boxed array. This will discard any possible slicing that has been
-- applied to the array.
--
-- @since 0.2.1
unwrapMutableArray :: MArray s B ix e -> A.MutableArray s e
unwrapMutableArray :: forall s ix e. MArray s B ix e -> MutableArray s e
unwrapMutableArray (MBArray (MBLArray Sz ix
_ Int
_ MutableArray s e
marr)) = MutableArray s e
marr
{-# INLINE unwrapMutableArray #-}

-- | /O(1)/ - Unwrap mutable boxed lazy array. This will discard any possible slicing that has been
-- applied to the array.
--
-- @since 0.6.0
unwrapMutableLazyArray :: MArray s BL ix e -> A.MutableArray s e
unwrapMutableLazyArray :: forall s ix e. MArray s BL ix e -> MutableArray s e
unwrapMutableLazyArray (MBLArray Sz ix
_ Int
_ MutableArray s e
marr) = MutableArray s e
marr
{-# INLINE unwrapMutableLazyArray #-}

-- | /O(n)/ - Wrap mutable boxed array and evaluate all elements to WHNF.
--
-- @since 0.2.1
evalMutableArray
  :: PrimMonad m
  => A.MutableArray (PrimState m) e
  -- ^ Mutable array that will get wrapped
  -> m (MArray (PrimState m) B Ix1 e)
evalMutableArray :: forall (m :: * -> *) e.
PrimMonad m =>
MutableArray (PrimState m) e -> m (MArray (PrimState m) B Int e)
evalMutableArray = (MArray (PrimState m) BL Int e -> MArray (PrimState m) B Int e)
-> m (MArray (PrimState m) BL Int e)
-> m (MArray (PrimState m) B Int e)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MArray (PrimState m) BL Int e -> MArray (PrimState m) B Int e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (m (MArray (PrimState m) BL Int e)
 -> m (MArray (PrimState m) B Int e))
-> (MutableArray (PrimState m) e
    -> m (MArray (PrimState m) BL Int e))
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) B Int e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> m () -> m ())
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) BL Int e)
forall (m :: * -> *) e a.
PrimMonad m =>
(e -> m () -> m a)
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) BL Int e)
fromMutableArraySeq e -> m () -> m ()
forall a b. a -> b -> b
seq
{-# INLINE evalMutableArray #-}

-------------------
-- NF conversion --
-------------------

-- | /O(1)/ - Unwrap a fully evaluated boxed array. This will discard any possible slicing
-- that has been applied to the array.
--
-- @since 0.2.1
unwrapNormalFormArray :: Array N ix e -> A.Array e
unwrapNormalFormArray :: forall ix e. Array BN ix e -> Array e
unwrapNormalFormArray = Array BL ix e -> Array e
forall ix e. Array BL ix e -> Array e
blData (Array BL ix e -> Array e)
-> (Array BN ix e -> Array BL ix e) -> Array BN ix e -> Array e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array BN ix e -> Array BL ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unwrapNormalFormArray #-}

-- | /O(n)/ - Wrap a boxed array and evaluate all elements to a Normal Form (NF).
--
-- @since 0.2.1
evalNormalFormArray
  :: NFData e
  => Comp
  -- ^ Computation strategy
  -> A.Array e
  -- ^ Lazy boxed array
  -> Array N Ix1 e
evalNormalFormArray :: forall e. NFData e => Comp -> Array e -> Array BN Int e
evalNormalFormArray Comp
comp = Array BL Int e -> Array BN Int e
forall e ix. (NFData e, Index ix) => Array BL ix e -> Array BN ix e
forceLazyArray (Array BL Int e -> Array BN Int e)
-> (Array e -> Array BL Int e) -> Array e -> Array BN Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Comp -> Array BL Int e -> Array BL Int e
forall r ix e. Strategy r => Comp -> Array r ix e -> Array r ix e
forall ix e. Comp -> Array BL ix e -> Array BL ix e
setComp Comp
comp (Array BL Int e -> Array BL Int e)
-> (Array e -> Array BL Int e) -> Array e -> Array BL Int e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array e -> Array BL Int e
forall e. Array e -> Vector BL e
wrapLazyArray
{-# INLINE evalNormalFormArray #-}

-- | /O(1)/ - Unwrap a fully evaluated mutable boxed array. This will discard any possible
-- slicing that has been applied to the array.
--
-- @since 0.2.1
unwrapNormalFormMutableArray :: MArray s N ix e -> A.MutableArray s e
unwrapNormalFormMutableArray :: forall s ix e. MArray s BN ix e -> MutableArray s e
unwrapNormalFormMutableArray = MArray s BL ix e -> MutableArray s e
forall s ix e. MArray s BL ix e -> MutableArray s e
unwrapMutableLazyArray (MArray s BL ix e -> MutableArray s e)
-> (MArray s BN ix e -> MArray s BL ix e)
-> MArray s BN ix e
-> MutableArray s e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s BN ix e -> MArray s BL ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unwrapNormalFormMutableArray #-}

-- | /O(n)/ - Wrap mutable boxed array and evaluate all elements to NF.
--
-- @since 0.2.1
evalNormalFormMutableArray
  :: (PrimMonad m, NFData e)
  => A.MutableArray (PrimState m) e
  -> m (MArray (PrimState m) N Ix1 e)
evalNormalFormMutableArray :: forall (m :: * -> *) e.
(PrimMonad m, NFData e) =>
MutableArray (PrimState m) e -> m (MArray (PrimState m) BN Int e)
evalNormalFormMutableArray MutableArray (PrimState m) e
marr = MArray (PrimState m) BL Int e -> MArray (PrimState m) BN Int e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray (PrimState m) BL Int e -> MArray (PrimState m) BN Int e)
-> m (MArray (PrimState m) BL Int e)
-> m (MArray (PrimState m) BN Int e)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (e -> m () -> m ())
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) BL Int e)
forall (m :: * -> *) e a.
PrimMonad m =>
(e -> m () -> m a)
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) BL Int e)
fromMutableArraySeq e -> m () -> m ()
forall a b. NFData a => a -> b -> b
deepseq MutableArray (PrimState m) e
marr
{-# INLINE evalNormalFormMutableArray #-}

----------------------
-- Helper functions --
----------------------

fromMutableArraySeq
  :: PrimMonad m
  => (e -> m () -> m a)
  -> A.MutableArray (PrimState m) e
  -> m (MArray (PrimState m) BL Ix1 e)
fromMutableArraySeq :: forall (m :: * -> *) e a.
PrimMonad m =>
(e -> m () -> m a)
-> MutableArray (PrimState m) e
-> m (MArray (PrimState m) BL Int e)
fromMutableArraySeq e -> m () -> m a
with MutableArray (PrimState m) e
ma = do
  let !sz :: Int
sz = MutableArray (PrimState m) e -> Int
forall s a. MutableArray s a -> Int
A.sizeofMutableArray MutableArray (PrimState m) e
ma
  Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()
forall (f :: * -> *) a.
Applicative f =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> f a) -> f ()
loopA_ Int
0 (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz) (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (MutableArray (PrimState m) e -> Int -> m e
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
A.readArray MutableArray (PrimState m) e
ma (Int -> m e) -> (e -> m a) -> Int -> m a
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (e -> m () -> m a
`with` () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()))
  MArray (PrimState m) BL Int e -> m (MArray (PrimState m) BL Int e)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (MArray (PrimState m) BL Int e
 -> m (MArray (PrimState m) BL Int e))
-> MArray (PrimState m) BL Int e
-> m (MArray (PrimState m) BL Int e)
forall a b. (a -> b) -> a -> b
$! Sz1
-> Int
-> MutableArray (PrimState m) e
-> MArray (PrimState m) BL Int e
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
sz) Int
0 MutableArray (PrimState m) e
ma
{-# INLINE fromMutableArraySeq #-}

seqArray :: Index ix => Array BL ix a -> t -> t
seqArray :: forall ix a t. Index ix => Array BL ix a -> t -> t
seqArray !Array BL ix a
arr t
t = (() -> a -> ())
-> () -> (() -> () -> ()) -> () -> Array BL ix a -> ()
forall ix r e a b.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> (b -> a -> b) -> b -> Array r ix e -> b
foldlInternal ((a -> () -> ()) -> () -> a -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> () -> ()
forall a b. a -> b -> b
seq) () ((() -> () -> ()) -> () -> () -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip () -> () -> ()
forall a b. a -> b -> b
seq) () Array BL ix a
arr () -> t -> t
forall a b. a -> b -> b
`seq` t
t
{-# INLINE seqArray #-}

deepseqArray :: (NFData a, Index ix) => Array BL ix a -> t -> t
deepseqArray :: forall a ix t. (NFData a, Index ix) => Array BL ix a -> t -> t
deepseqArray !Array BL ix a
arr t
t = (() -> a -> ())
-> () -> (() -> () -> ()) -> () -> Array BL ix a -> ()
forall ix r e a b.
(Index ix, Source r e) =>
(a -> e -> a) -> a -> (b -> a -> b) -> b -> Array r ix e -> b
foldlInternal ((a -> () -> ()) -> () -> a -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> () -> ()
forall a b. NFData a => a -> b -> b
deepseq) () ((() -> () -> ()) -> () -> () -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip () -> () -> ()
forall a b. a -> b -> b
seq) () Array BL ix a
arr () -> t -> t
forall a b. a -> b -> b
`seq` t
t
{-# INLINE deepseqArray #-}

-- | /O(1)/ - Converts array from `N` to `B` representation.
--
-- @since 0.5.0
unwrapNormalForm :: Array N ix e -> Array B ix e
unwrapNormalForm :: forall ix e. Array BN ix e -> Array B ix e
unwrapNormalForm = Array BN ix e -> Array B ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE unwrapNormalForm #-}

-- | /O(n)/ - Compute all elements of a boxed array to NF (normal form)
--
-- @since 0.5.0
evalNormalForm :: (Index ix, NFData e) => Array B ix e -> Array N ix e
evalNormalForm :: forall ix e. (Index ix, NFData e) => Array B ix e -> Array BN ix e
evalNormalForm (BArray Array BL ix e
arr) = Array BL ix e
arr Array BL ix e -> Array BN ix e -> Array BN ix e
forall a ix t. (NFData a, Index ix) => Array BL ix a -> t -> t
`deepseqArray` Array BL ix e -> Array BN ix e
forall ix e. Array BL ix e -> Array BN ix e
BNArray Array BL ix e
arr
{-# INLINE evalNormalForm #-}

{- FOURMOLU_DISABLE -}
-- | /O(1)/ - Converts a boxed `Array` into a `VB.Vector` without touching any
-- elements.
--
-- @since 0.5.0
{-# INLINE toBoxedVector #-}
toBoxedVector :: Index ix => Array BL ix a -> VB.Vector a
toBoxedVector :: forall ix a. Index ix => Array BL ix a -> Vector a
toBoxedVector BLArray{blOffset :: forall ix e. Array BL ix e -> Int
blOffset = Int
off, blSize :: forall ix e. Array BL ix e -> Sz ix
blSize = Sz ix
sz, blData :: forall ix e. Array BL ix e -> Array e
blData = Array a
arr } =
#if MIN_VERSION_vector(0,13,0)
  Array a -> Int -> Int -> Vector a
forall a. Array a -> Int -> Int -> Vector a
VB.unsafeFromArraySlice Array a
arr Int
off (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz)
#elif MIN_VERSION_vector(0,12,2)
  VB.unsafeTake (totalElem sz) (VB.unsafeDrop off (VB.fromArray arr))
#else
  fromVectorCast $ VectorCast off (totalElem sz) arr

fromVectorCast :: VectorCast a -> VB.Vector a
fromVectorCast = unsafeCoerce
#endif
{- FOURMOLU_ENABLE -}

-- | /O(1)/ - Converts a boxed `MArray` into a `MVB.MVector`.
--
-- @since 0.5.0
toBoxedMVector :: Index ix => MArray s BL ix a -> MVB.MVector s a
toBoxedMVector :: forall ix s a. Index ix => MArray s BL ix a -> MVector s a
toBoxedMVector (MBLArray Sz ix
sz Int
o MutableArray s a
marr) = Int -> Int -> MutableArray s a -> MVector s a
forall s a. Int -> Int -> MutableArray s a -> MVector s a
MVB.MVector Int
o (Sz ix -> Int
forall ix. Index ix => Sz ix -> Int
totalElem Sz ix
sz) MutableArray s a
marr
{-# INLINE toBoxedMVector #-}

-- | /O(n)/ - Convert a boxed vector and evaluate all elements to WHNF. Computation
-- strategy will be respected during evaluation
--
-- @since 0.5.0
evalBoxedVector :: Comp -> VB.Vector a -> Array B Ix1 a
evalBoxedVector :: forall a. Comp -> Vector a -> Array B Int a
evalBoxedVector Comp
comp = Array BL Int a -> Array B Int a
forall ix e. Index ix => Array BL ix e -> Array B ix e
evalLazyArray (Array BL Int a -> Array B Int a)
-> (Vector a -> Array BL Int a) -> Vector a -> Array B Int a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Comp -> Array BL Int a -> Array BL Int a
forall r ix e. Strategy r => Comp -> Array r ix e -> Array r ix e
forall ix e. Comp -> Array BL ix e -> Array BL ix e
setComp Comp
comp (Array BL Int a -> Array BL Int a)
-> (Vector a -> Array BL Int a) -> Vector a -> Array BL Int a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector a -> Array BL Int a
forall a. Vector a -> Vector BL a
fromBoxedVector
{-# INLINE evalBoxedVector #-}

-- | /O(n)/ - Convert mutable boxed vector and evaluate all elements to WHNF
-- sequentially. Both keep pointing to the same memory
--
-- @since 0.5.0
evalBoxedMVector :: PrimMonad m => MVB.MVector (PrimState m) a -> m (MArray (PrimState m) B Ix1 a)
evalBoxedMVector :: forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> m (MArray (PrimState m) B Int a)
evalBoxedMVector (MVB.MVector Int
o Int
k MutableArray (PrimState m) a
ma) =
  let marr :: MArray (PrimState m) B Int a
marr = MArray (PrimState m) BL Int a -> MArray (PrimState m) B Int a
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (Sz1
-> Int
-> MutableArray (PrimState m) a
-> MArray (PrimState m) BL Int a
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
k) Int
o MutableArray (PrimState m) a
ma)
   in MArray (PrimState m) B Int a
marr MArray (PrimState m) B Int a
-> m () -> m (MArray (PrimState m) B Int a)
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m ()) -> m ()
forall (f :: * -> *) a.
Applicative f =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> f a) -> f ()
loopA_ Int
o (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
k) (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
A.readArray MutableArray (PrimState m) a
ma (Int -> m a) -> (a -> m ()) -> Int -> m ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> m () -> m ()
forall a b. a -> b -> b
`seq` () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()))
{-# INLINE evalBoxedMVector #-}

-- | /O(1)/ - Cast a boxed vector without touching any elements.
--
-- @since 0.6.0
fromBoxedVector :: VB.Vector a -> Vector BL a
{-# INLINE fromBoxedVector #-}
fromBoxedVector :: forall a. Vector a -> Vector BL a
fromBoxedVector Vector a
v =
  BLArray{blComp :: Comp
blComp = Comp
Seq, blSize :: Sz1
blSize = Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
n, blOffset :: Int
blOffset = Int
offset, blData :: Array a
blData = Array a
arr}
  where
#if MIN_VERSION_vector(0,13,0)
    (Array a
arr, Int
offset, Int
n) = Vector a -> (Array a, Int, Int)
forall a. Vector a -> (Array a, Int, Int)
VB.toArraySlice Vector a
v
#else
    VectorCast offset n arr = toVectorCast v

-- This internal type is needed to get into the internals of a boxed vector,
-- since it is not possible until vector-0.13 version.
data VectorCast a =
  VectorCast {-# UNPACK #-}!Int {-# UNPACK #-}!Int {-# UNPACK #-}!(A.Array a)

toVectorCast :: VB.Vector a -> VectorCast a
toVectorCast = unsafeCoerce
#endif

-- | /O(1)/ - Convert mutable boxed vector to a lazy mutable boxed array. Both keep
-- pointing to the same memory
--
-- @since 0.6.0
fromBoxedMVector :: MVB.MVector s a -> MArray s BL Ix1 a
fromBoxedMVector :: forall s a. MVector s a -> MArray s BL Int a
fromBoxedMVector (MVB.MVector Int
o Int
k MutableArray s a
ma) = Sz1 -> Int -> MutableArray s a -> MArray s BL Int a
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
k) Int
o MutableArray s a
ma
{-# INLINE fromBoxedMVector #-}

-- | /O(1)/ - Cast a boxed lazy array. It is unsafe because it can violate the invariant
-- that all elements of `N` array are in NF.
--
-- @since 0.6.0
coerceNormalBoxedArray :: Array BL ix e -> Array N ix e
coerceNormalBoxedArray :: forall ix e. Array BL ix e -> Array BN ix e
coerceNormalBoxedArray = Array BL ix e -> Array BN ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE coerceNormalBoxedArray #-}

-- | /O(1)/ - Cast a boxed lazy array. It is unsafe because it can violate the invariant
-- that all elements of `B` array are in WHNF.
--
-- @since 0.6.0
coerceBoxedArray :: Array BL ix e -> Array B ix e
coerceBoxedArray :: forall ix e. Array BL ix e -> Array B ix e
coerceBoxedArray = Array BL ix e -> Array B ix e
forall a b. Coercible a b => a -> b
coerce
{-# INLINE coerceBoxedArray #-}

-- | /O(n)/ - Convert mutable boxed vector and evaluate all elements to WHNF
-- sequentially. Both keep pointing to the same memory
--
-- @since 0.5.0
evalNormalBoxedMVector
  :: (NFData a, PrimMonad m) => MVB.MVector (PrimState m) a -> m (MArray (PrimState m) N Ix1 a)
evalNormalBoxedMVector :: forall a (m :: * -> *).
(NFData a, PrimMonad m) =>
MVector (PrimState m) a -> m (MArray (PrimState m) BN Int a)
evalNormalBoxedMVector (MVB.MVector Int
o Int
k MutableArray (PrimState m) a
ma) =
  let marr :: MArray (PrimState m) BN Int a
marr = MArray (PrimState m) BL Int a -> MArray (PrimState m) BN Int a
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (Sz1
-> Int
-> MutableArray (PrimState m) a
-> MArray (PrimState m) BL Int a
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
k) Int
o MutableArray (PrimState m) a
ma)
   in MArray (PrimState m) BN Int a
marr MArray (PrimState m) BN Int a
-> m () -> m (MArray (PrimState m) BN Int a)
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m ()) -> m ()
forall (f :: * -> *) a.
Applicative f =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> f a) -> f ()
loopA_ Int
o (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
k) (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
A.readArray MutableArray (PrimState m) a
ma (Int -> m a) -> (a -> m ()) -> Int -> m ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> () -> m ()
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (() -> m ()) -> (a -> ()) -> a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ()
forall a. NFData a => a -> ()
rnf)
{-# INLINE evalNormalBoxedMVector #-}

-- | /O(n)/ - Convert a boxed vector and evaluate all elements to WHNF. Computation
-- strategy will be respected during evaluation
--
-- @since 0.5.0
evalNormalBoxedVector :: NFData a => Comp -> VB.Vector a -> Array N Ix1 a
evalNormalBoxedVector :: forall a. NFData a => Comp -> Vector a -> Array BN Int a
evalNormalBoxedVector Comp
comp Vector a
v =
  (forall s. ST s (Array BN Int a)) -> Array BN Int a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Array BN Int a)) -> Array BN Int a)
-> (forall s. ST s (Array BN Int a)) -> Array BN Int a
forall a b. (a -> b) -> a -> b
$ do
    MVB.MVector Int
o Int
k MutableArray s a
ma <- Vector a -> ST s (MVector (PrimState (ST s)) a)
forall (m :: * -> *) a.
PrimMonad m =>
Vector a -> m (MVector (PrimState m) a)
VB.unsafeThaw Vector a
v
    Array BL Int a -> Array BN Int a
forall e ix. (NFData e, Index ix) => Array BL ix e -> Array BN ix e
forceLazyArray (Array BL Int a -> Array BN Int a)
-> ST s (Array BL Int a) -> ST s (Array BN Int a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Comp -> MArray (PrimState (ST s)) BL Int a -> ST s (Array BL Int a)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) r ix e -> m (Array r ix e)
forall ix (m :: * -> *).
(Index ix, PrimMonad m) =>
Comp -> MArray (PrimState m) BL ix a -> m (Array BL ix a)
unsafeFreeze Comp
comp (Sz1 -> Int -> MutableArray s a -> MArray s BL Int a
forall s ix e. Sz ix -> Int -> MutableArray s e -> MArray s BL ix e
MBLArray (Int -> Sz1
forall ix. ix -> Sz ix
SafeSz Int
k) Int
o MutableArray s a
ma)
{-# INLINE evalNormalBoxedVector #-}