{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
-- |
-- Module      : Data.Massiv.Array.Manifest.Boxed
-- Copyright   : (c) Alexey Kuleshevich 2018-2021
-- 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.Push (DL)
import Data.Massiv.Array.Delayed.Stream (DS)
import Data.Massiv.Array.Manifest.Internal (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 Prelude hiding (mapM, replicate)
import System.IO.Unsafe (unsafePerformIO)

#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
showList :: [BL] -> ShowS
$cshowList :: [BL] -> ShowS
show :: BL -> String
$cshow :: BL -> String
showsPrec :: Int -> BL -> ShowS
$cshowsPrec :: Int -> BL -> ShowS
Show

data instance Array BL ix e = BLArray { Array BL ix e -> Comp
blComp   :: !Comp
                                      , Array BL ix e -> Sz ix
blSize   :: !(Sz ix)
                                      , Array BL ix e -> Int
blOffset :: {-# UNPACK #-} !Int
                                      , 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 :: Comp -> Array BL ix e -> Array BL ix e
setComp Comp
c Array BL ix e
arr = Array BL ix e
R:ArrayBLixe ix e
arr { blComp :: Comp
blComp = Comp
c }
  {-# INLINE setComp #-}
  getComp :: Array BL ix e -> Comp
getComp = Array BL ix e -> Comp
forall ix e. Array BL ix e -> Comp
blComp
  {-# INLINE getComp #-}


instance Source BL e where
  unsafeLinearIndex :: Array BL ix e -> Int -> e
unsafeLinearIndex (BLArray _ _sz o a) Int
i =
    INDEX_CHECK("(Source BL ix e).unsafeLinearIndex",
                SafeSz . A.sizeofArray, A.indexArray) a (i + o)
  {-# INLINE unsafeLinearIndex #-}

  unsafeOuterSlice :: Array BL ix e -> Sz (Lower ix) -> Int -> Array BL (Lower ix) e
unsafeOuterSlice (BLArray c _ o 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 :: Int -> Sz1 -> Array BL ix e -> Array BL Int e
unsafeLinearSlice Int
i Sz1
k (BLArray c _ o 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 :: Array BL ix e -> Int -> e
unsafeLinearIndexM (BLArray _ _sz o a) Int
i =
    INDEX_CHECK("(Manifest BL ix e).unsafeLinearIndexM",
                SafeSz . A.sizeofArray, A.indexArray) a (i + o)
  {-# INLINE unsafeLinearIndexM #-}

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

  unsafeResizeMArray :: Sz ix' -> MArray s BL ix e -> MArray s BL ix' e
unsafeResizeMArray Sz ix'
sz (MBLArray _ off 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 :: Int -> Sz1 -> MArray s BL ix e -> MVector s BL e
unsafeLinearSliceMArray Int
i Sz1
k (MBLArray _ o a) = Sz1 -> Int -> MutableArray s e -> MVector s BL 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 :: Array BL ix e -> m (MArray (PrimState m) BL ix e)
unsafeThaw (BLArray _ sz o 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 :: Comp -> MArray (PrimState m) BL ix e -> m (Array BL ix e)
unsafeFreeze Comp
comp (MBLArray sz o 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 :: 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 :: MArray (PrimState m) BL ix e -> m ()
initialize MArray (PrimState m) BL ix e
_ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  {-# INLINE initialize #-}

  newMArray :: 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 :: MArray (PrimState m) BL ix e -> Int -> m e
unsafeLinearRead (MBLArray _ o ma) Int
i =
    INDEX_CHECK("(Manifest BL ix e).unsafeLinearRead",
                SafeSz . A.sizeofMutableArray, A.readArray) ma (i + o)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: MArray (PrimState m) BL ix e -> Int -> e -> m ()
unsafeLinearWrite (MBLArray _sz o ma) Int
i e
e =
    INDEX_CHECK("(Manifest BL ix e).unsafeLinearWrite",
                SafeSz . A.sizeofMutableArray, A.writeArray) ma (i + o) e
  {-# INLINE unsafeLinearWrite #-}

instance Size BL where
  size :: 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 :: Sz ix' -> Array BL ix e -> Array BL ix' e
unsafeResize !Sz ix'
sz !Array BL ix e
arr = Array BL ix e
R:ArrayBLixe ix e
arr { blSize :: Sz ix'
blSize = Sz ix'
sz }
  {-# INLINE unsafeResize #-}


instance Index ix => Shape BL ix where
  maxLinearSize :: 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
  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 (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)
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 (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)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}

  iterArrayLinearST_ :: 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 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 :: 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 :: (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 :: (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' :: (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 :: (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' :: (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 :: Array BL ix a -> Bool
null (BLArray _ sz _ _) = 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 :: 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
size
  {-# INLINE length #-}
  toList :: 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 :: (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 r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array BL ix a
arr)
  {-# INLINE fmap #-}
  <$ :: 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
getComp Array BL ix b
arr) (Array BL ix b -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
size Array BL ix b
arr) a
e
  {-# INLINE (<$) #-}

instance Index ix => Traversable (Array BL ix) where
  traverse :: (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 -> [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 :: 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 :: 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 :: (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 :: (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 :: (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
showList :: [B] -> ShowS
$cshowList :: [B] -> ShowS
show :: B -> String
$cshow :: B -> String
showsPrec :: Int -> B -> ShowS
$cshowsPrec :: Int -> 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
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 :: Array B ix e -> Int -> e
unsafeLinearIndex Array B ix e
arr = 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 :: 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
coerce (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 :: 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
coerce (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 :: 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
coerce
  {-# INLINE getComp #-}
  setComp :: 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
coerce Array B ix e
arr) { blComp :: Comp
blComp = Comp
c }
  {-# INLINE setComp #-}


instance Index ix => Shape B ix where
  maxLinearSize :: 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 :: 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
coerce
  {-# INLINE size #-}
  unsafeResize :: 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
coerce (\Array BL ix e
arr -> Array BL ix e
R:ArrayBLixe ix e
arr { blSize :: Sz ix'
blSize = Sz ix'
sz })
  {-# INLINE unsafeResize #-}


instance Manifest B e where

  unsafeLinearIndexM :: Array B ix e -> Int -> e
unsafeLinearIndexM = (Array BL ix e -> Int -> e) -> Array B ix e -> Int -> e
coerce 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 :: MArray s B ix e -> Sz ix
sizeOfMArray = 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
coerce
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: 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
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
coerce
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: Int -> Sz1 -> MArray s B ix e -> MVector s B e
unsafeLinearSliceMArray Int
i Sz1
k = MArray s BL Int e -> MVector s B e
forall s ix e. MArray s BL ix e -> MArray s B ix e
MBArray (MArray s BL Int e -> MVector s B e)
-> (MArray s B ix e -> MArray s BL Int e)
-> MArray s B ix e
-> MVector s B e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1 -> MArray s BL ix e -> MArray s BL Int 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
coerce
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: 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)
unsafeThaw (Array B ix e -> Array BL ix e
coerce Array B ix e
arr)
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: 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)
unsafeFreeze Comp
comp (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) B ix e
marr)
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: 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)
unsafeNew Sz ix
sz
  {-# INLINE unsafeNew #-}

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

  newMArray :: 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)
newMArray Sz ix
sz e
e
  {-# INLINE newMArray #-}

  unsafeLinearRead :: 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
unsafeLinearRead (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) B ix e
ma)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: 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 ()
`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 ()
unsafeLinearWrite (MArray (PrimState m) B ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) B ix e
ma) Int
i e
e
  {-# INLINE unsafeLinearWrite #-}

instance Index ix => Load B ix e where
  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 (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)
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 (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)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}

  iterArrayLinearST_ :: 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 ()
coerce (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 :: 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 :: (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 :: (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' :: (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 :: (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' :: (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 :: 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
size Array B ix a
arr) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
  {-# INLINE null #-}
  length :: 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
size
  {-# INLINE length #-}
  toList :: 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 :: (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
getComp Array B ix a
arr) (Array B ix a -> Sz ix
forall r ix e. Size r => Array r 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 r e ix. (Source r e, Index ix) => Array r ix e -> Int -> e
unsafeLinearIndex Array B ix a
arr)
  {-# INLINE fmap #-}
  <$ :: 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
getComp Array B ix b
arr) (Array B ix b -> Sz ix
forall r ix e. Size r => Array r ix e -> Sz ix
size Array B ix b
arr) a
e
  {-# INLINE (<$) #-}

instance Index ix => Traversable (Array B ix) where
  traverse :: (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 -> [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 :: 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 :: 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 :: (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 :: (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 :: (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
showList :: [BN] -> ShowS
$cshowList :: [BN] -> ShowS
show :: BN -> String
$cshow :: BN -> String
showsPrec :: Int -> BN -> ShowS
$cshowsPrec :: Int -> 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 $bN :: BN
$mN :: forall r. BN -> (Void# -> r) -> (Void# -> r) -> r
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
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 -> () -> ()
`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 N where
  setComp :: 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
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
setComp Comp
c)
  {-# INLINE setComp #-}
  getComp :: 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
coerce
  {-# INLINE getComp #-}

instance NFData e => Source BN e where
  unsafeLinearIndex :: Array BN ix e -> Int -> e
unsafeLinearIndex (BNArray arr) = 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 :: Int -> Sz1 -> Array BN ix e -> Array BN Int e
unsafeLinearSlice Int
i Sz1
k (BNArray a) = Array BL Int e -> Array BN Int e
coerce (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 :: Array BN ix e -> Sz (Lower ix) -> Int -> Array BN (Lower ix) e
unsafeOuterSlice (BNArray a) Sz (Lower ix)
i = (Int -> Array BL (Lower ix) e) -> Int -> Array BN (Lower ix) e
coerce (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 :: 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 :: 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
coerce
  {-# INLINE size #-}

  unsafeResize :: Sz ix' -> Array BN ix e -> Array BN ix' e
unsafeResize !Sz ix'
sz = Array BL ix' e -> Array BN ix' e
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
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
coerce
  {-# INLINE unsafeResize #-}

instance NFData e => Manifest BN e where
  unsafeLinearIndexM :: Array BN ix e -> Int -> e
unsafeLinearIndexM Array BN ix e
arr = 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
coerce Array BN ix e
arr)
  {-# INLINE unsafeLinearIndexM #-}

  sizeOfMArray :: MArray s BN ix e -> Sz ix
sizeOfMArray = 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
coerce
  {-# INLINE sizeOfMArray #-}

  unsafeResizeMArray :: 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
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
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
coerce
  {-# INLINE unsafeResizeMArray #-}

  unsafeLinearSliceMArray :: Int -> Sz1 -> MArray s BN ix e -> MVector s BN e
unsafeLinearSliceMArray Int
i Sz1
k = MArray s BL Int e -> MVector s BN e
forall s ix e. MArray s BL ix e -> MArray s BN ix e
MBNArray (MArray s BL Int e -> MVector s BN e)
-> (MArray s BN ix e -> MArray s BL Int e)
-> MArray s BN ix e
-> MVector s BN e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Sz1 -> MArray s BL ix e -> MArray s BL Int 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
coerce
  {-# INLINE unsafeLinearSliceMArray #-}

  unsafeThaw :: 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)
unsafeThaw (Array BN ix e -> Array BL ix e
coerce Array BN ix e
arr)
  {-# INLINE unsafeThaw #-}

  unsafeFreeze :: 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)
unsafeFreeze Comp
comp (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) BN ix e
marr)
  {-# INLINE unsafeFreeze #-}

  unsafeNew :: 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)
unsafeNew Sz ix
sz
  {-# INLINE unsafeNew #-}

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

  newMArray :: 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)
newMArray Sz ix
sz e
e)
  {-# INLINE newMArray #-}

  unsafeLinearRead :: 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
unsafeLinearRead (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) BN ix e
ma)
  {-# INLINE unsafeLinearRead #-}

  unsafeLinearWrite :: 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 ()
unsafeLinearWrite (MArray (PrimState m) BN ix e -> MArray (PrimState m) BL ix e
coerce MArray (PrimState m) BN ix e
ma) Int
i e
e
  {-# INLINE unsafeLinearWrite #-}

instance (Index ix, NFData e) => Load BN ix e where
  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 (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)
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 (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)
unsafeFreeze Comp
comp)
  {-# INLINE replicate #-}
  iterArrayLinearST_ :: 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 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
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
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 -> [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 :: 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 :: 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 :: (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 :: (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 :: (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 :: 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 :: 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
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 :: Comp -> Array e -> Vector B e
evalArray Comp
comp Array e
a = Array BL Int e -> Vector B e
forall ix e. Index ix => Array BL ix e -> Array B ix e
evalLazyArray (Array BL Int e -> Vector B e) -> Array BL Int e -> Vector B 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
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 :: 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 :: Array e -> Vector BL e
wrapLazyArray Array e
a = Comp -> Sz1 -> Int -> Array e -> Vector BL 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 :: Array B ix e -> Array BL ix e
toLazyArray = Array B ix e -> Array BL ix e
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 :: 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 :: 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 :: MArray s B ix e -> MutableArray s e
unwrapMutableArray (MBArray (MBLArray _ _ 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 :: MArray s BL ix e -> MutableArray s e
unwrapMutableLazyArray (MBLArray _ _ 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 :: 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 (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 ()
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 :: 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
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 :: 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
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 :: 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
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 :: 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 :: (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 (m :: * -> *) a.
Monad m =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()
loopM_ 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 (m :: * -> *) a. Monad m => a -> m a
return ()))
  MArray (PrimState m) BL Int e -> m (MArray (PrimState m) BL Int e)
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 :: 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 -> () -> ()
seq) () ((() -> () -> ()) -> () -> () -> ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip () -> () -> ()
seq) () Array BL ix a
arr () -> t -> t
`seq` t
t
{-# INLINE seqArray #-}


deepseqArray :: (NFData a, Index ix) => Array BL ix a -> t -> t
deepseqArray :: 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 () -> () -> ()
seq) () Array BL ix a
arr () -> t -> t
`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 :: Array BN ix e -> Array B ix e
unwrapNormalForm = Array BN ix e -> Array B ix e
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 :: Array B ix e -> Array BN ix e
evalNormalForm (BArray 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 #-}

-- | /O(1)/ - Converts a boxed `Array` into a `VB.Vector`.
--
-- @since 0.5.0
toBoxedVector :: Index ix => Array BL ix a -> VB.Vector a
toBoxedVector :: Array BL ix a -> Vector a
toBoxedVector Array BL ix a
arr = (forall s. ST s (Vector a)) -> Vector a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vector a)) -> Vector a)
-> (forall s. ST s (Vector a)) -> Vector a
forall a b. (a -> b) -> a -> b
$ MVector s a -> ST s (Vector a)
forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> m (Vector a)
VB.unsafeFreeze (MVector s a -> ST s (Vector a))
-> (MArray s BL ix a -> MVector s a)
-> MArray s BL ix a
-> ST s (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MArray s BL ix a -> MVector s a
forall ix s a. Index ix => MArray s BL ix a -> MVector s a
toBoxedMVector (MArray s BL ix a -> ST s (Vector a))
-> ST s (MArray s BL ix a) -> ST s (Vector a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Array BL ix a -> ST s (MArray (PrimState (ST s)) BL ix a)
forall r e ix (m :: * -> *).
(Manifest r e, Index ix, PrimMonad m) =>
Array r ix e -> m (MArray (PrimState m) r ix e)
unsafeThaw Array BL ix a
arr
{-# INLINE toBoxedVector #-}

-- | /O(1)/ - Converts a boxed `MArray` into a `VMB.MVector`.
--
-- @since 0.5.0
toBoxedMVector :: Index ix => MArray s BL ix a -> MVB.MVector s a
toBoxedMVector :: MArray s BL ix a -> MVector s a
toBoxedMVector (MBLArray sz o 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 :: 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
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 :: 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 (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m ()) -> m ()
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()
loopM_ 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 ()
`seq` () -> m ()
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
fromBoxedVector :: Vector a -> Vector BL a
fromBoxedVector Vector a
v =
  (forall s. ST s (Vector BL a)) -> Vector BL a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vector BL a)) -> Vector BL a)
-> (forall s. ST s (Vector BL a)) -> Vector BL 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
    Comp -> MArray (PrimState (ST s)) BL Int a -> ST s (Vector BL 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)
unsafeFreeze Comp
Seq (MArray (PrimState (ST s)) BL Int a -> ST s (Vector BL a))
-> MArray (PrimState (ST s)) BL Int a -> ST s (Vector BL a)
forall a b. (a -> b) -> a -> b
$ 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 fromBoxedVector #-}


-- | /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 :: 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 :: Array BL ix e -> Array BN ix e
coerceNormalBoxedArray = Array BL ix e -> Array BN ix e
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 :: Array BL ix e -> Array B ix e
coerceBoxedArray = Array BL ix e -> Array B ix e
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 :: 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 (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m ()) -> m ()
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> Bool) -> (Int -> Int) -> (Int -> m a) -> m ()
loopM_ 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. NFData a => a -> b -> b
`deepseq` () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()))
{-# 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 :: 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)
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 #-}