Numerical.Array.Mutable

Documentation

data family MArray world rep lay (view :: Locality) (rank :: Nat) st el

MArray is the generic data family that

Instances

(Buffer rep el, Layout (Format lay locality rank rep) rank) => Array (MArray Native rep lay locality rank) rank el

Defined in Numerical.Array.Mutable

Associated Types

type ArrPure (MArray Native rep lay locality rank) :: Type -> Type

type MArrayAddress (MArray Native rep lay locality rank) :: Type

Methods

basicUnsafeAffineAddressShift :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Int -> address -> address

basicUnsafeFreeze :: (PrimMonad m, arr ~ ArrPure (MArray Native rep lay locality rank), MArray Native rep lay locality rank ~ ArrMutable arr) => MArray Native rep lay locality rank (PrimState m) el -> m (arr el)

basicUnsafeThaw :: (PrimMonad m, MArray Native rep lay locality rank ~ ArrMutable arr, arr ~ ArrPure (MArray Native rep lay locality rank)) => arr el -> m (MArray Native rep lay locality rank (PrimState m) el)

basicShape :: MArray Native rep lay locality rank st el -> Index rank

basicCardinality :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Range address -> Int

basicSparseIndexToAddress :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank s el -> Index rank -> Maybe address

basicAddressToIndex :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank s el -> address -> Index rank

basicAddressRange :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Maybe (Range address)

basicSparseNextAddress :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> address -> Maybe address

basicSparseNextIndex :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Index rank -> Maybe address -> Maybe (Index rank, address)

basicLocalAffineAddressRegion :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> address -> AffineRange address

basicOverlaps :: MArray Native rep lay locality rank st el -> MArray Native rep lay locality rank st el -> Bool

basicClear :: PrimMonad m => MArray Native rep lay locality rank (PrimState m) el -> m ()

basicUnsafeAddressRead :: (PrimMonad m, address ~ MArrayAddress (MArray Native rep lay locality rank)) => MArray Native rep lay locality rank (PrimState m) el -> address -> m el

basicUnsafeAddressWrite :: (PrimMonad m, address ~ MArrayAddress (MArray Native rep lay locality rank)) => MArray Native rep lay locality rank (PrimState m) el -> address -> el -> m ()

basicUnsafeSparseRead :: PrimMonad m => MArray Native rep lay locality rank (PrimState m) el -> Index rank -> m (Maybe el)

data MArray Native rep lay locality rank st el

Defined in Numerical.Array.Mutable

data MArray Native rep lay locality rank st el = MutableNativeArray {

• nativeBuffer :: !(BufferMut rep st el)
• nativeFormat :: !(Format lay locality rank rep)

}

type ArrPure (MArray Native rep lay locality rank)

Defined in Numerical.Array.Mutable

type ArrPure (MArray Native rep lay locality rank) = ImmArray Native rep lay locality rank

type MArrayAddress (MArray Native rep lay locality rank)

Defined in Numerical.Array.Mutable

type MArrayAddress (MArray Native rep lay locality rank) = LayoutAddress (Format lay locality rank rep)

class PureArray (ArrPure marr) rank a => Array marr (rank :: Nat) a | marr -> rank where

Associated Types

type ArrPure (marr :: * -> * -> *) :: * -> *

type MArrayAddress (marr :: * -> * -> *) :: *

Methods

basicUnsafeAffineAddressShift :: address ~ MArrayAddress marr => marr st a -> Int -> address -> address

basicUnsafeAffineAddressShift is needed to handle abstracting access in popcount space

basicUnsafeFreeze :: (PrimMonad m, arr ~ ArrPure marr, marr ~ ArrMutable arr) => marr (PrimState m) a -> m (arr a)

Unsafely convert a mutable Array to its immutable version without copying. The mutable Array may not be used after this operation. Assumed O(1) complexity

basicUnsafeThaw :: (PrimMonad m, marr ~ ArrMutable arr, arr ~ ArrPure marr) => arr a -> m (marr (PrimState m) a)

Unsafely convert a pure Array to its mutable version without copying. the pure array may not be used after this operation. Assumed O(1) complexity

basicShape :: marr st a -> Index rank

gives the shape, a rank length list of the dimensions

basicCardinality :: address ~ MArrayAddress marr => marr st a -> Range address -> Int

basicCardinality reports the number of manifest addresses/entries are in the array in a given address sub range. This is useful for determining when to switch from a recursive algorithm to a direct algorithm. Should this be renamed to something like basicPopCount/

basicSparseIndexToAddress :: address ~ MArrayAddress marr => marr s a -> Index rank -> Maybe address

basicAddressToIndex :: address ~ MArrayAddress marr => marr s a -> address -> Index rank

basicMutableAddressToIndex assumes you only give it legal manifest addresses

basicAddressRange :: address ~ MArrayAddress marr => marr st a -> Maybe (Range address)

return the smallest and largest valid logical address

basicSparseNextAddress :: address ~ MArrayAddress marr => marr st a -> address -> Maybe address

gives the next valid logical address undefined on invalid addresses and the greatest valid address. Note that for invalid addresses in between minAddress and maxAddress, will return the next valid address.

basicSparseNextIndex :: address ~ MArrayAddress marr => marr st a -> Index rank -> Maybe address -> Maybe (Index rank, address)

gives the next valid array index, the least valid index that is or

basicLocalAffineAddressRegion :: address ~ MArrayAddress marr => marr st a -> address -> AffineRange address

for a given valid address, basicAddressRegion addr will return an AddressInterval that contains addr. This will be a singleton when the "maximal uniform stride interval" containing addr has strictly less than 3 elements. Otherwise will return an Address range covering the maximal interval that will have cardinality at least 3.

basicOverlaps :: marr st a -> marr st a -> Bool

this doesn't quite fit in this class, but thats ok, will deal with that later

basicClear :: PrimMonad m => marr (PrimState m) a -> m ()

Reset all elements of the vector to some undefined value, clearing all references to external objects. This is usually a noop for unboxed vectors. This method should not be called directly, use clear instead.

basicUnsafeAddressRead :: (PrimMonad m, address ~ MArrayAddress marr) => marr (PrimState m) a -> address -> m a

basicUnsafeAddressWrite :: (PrimMonad m, address ~ MArrayAddress marr) => marr (PrimState m) a -> address -> a -> m ()

basicUnsafeSparseRead :: PrimMonad m => marr (PrimState m) a -> Index rank -> m (Maybe a)

Yield the element at the given position. This method should not be called directly, use unsafeSparseRead instead.

Instances

(Buffer rep el, Layout (Format lay locality rank rep) rank) => Array (MArray Native rep lay locality rank) rank el

Defined in Numerical.Array.Mutable

Associated Types

type ArrPure (MArray Native rep lay locality rank) :: Type -> Type

type MArrayAddress (MArray Native rep lay locality rank) :: Type

Methods

basicUnsafeAffineAddressShift :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Int -> address -> address

basicUnsafeFreeze :: (PrimMonad m, arr ~ ArrPure (MArray Native rep lay locality rank), MArray Native rep lay locality rank ~ ArrMutable arr) => MArray Native rep lay locality rank (PrimState m) el -> m (arr el)

basicUnsafeThaw :: (PrimMonad m, MArray Native rep lay locality rank ~ ArrMutable arr, arr ~ ArrPure (MArray Native rep lay locality rank)) => arr el -> m (MArray Native rep lay locality rank (PrimState m) el)

basicShape :: MArray Native rep lay locality rank st el -> Index rank

basicCardinality :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Range address -> Int

basicSparseIndexToAddress :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank s el -> Index rank -> Maybe address

basicAddressToIndex :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank s el -> address -> Index rank

basicAddressRange :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Maybe (Range address)

basicSparseNextAddress :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> address -> Maybe address

basicSparseNextIndex :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> Index rank -> Maybe address -> Maybe (Index rank, address)

basicLocalAffineAddressRegion :: address ~ MArrayAddress (MArray Native rep lay locality rank) => MArray Native rep lay locality rank st el -> address -> AffineRange address

basicOverlaps :: MArray Native rep lay locality rank st el -> MArray Native rep lay locality rank st el -> Bool

basicClear :: PrimMonad m => MArray Native rep lay locality rank (PrimState m) el -> m ()

basicUnsafeAddressRead :: (PrimMonad m, address ~ MArrayAddress (MArray Native rep lay locality rank)) => MArray Native rep lay locality rank (PrimState m) el -> address -> m el

basicUnsafeAddressWrite :: (PrimMonad m, address ~ MArrayAddress (MArray Native rep lay locality rank)) => MArray Native rep lay locality rank (PrimState m) el -> address -> el -> m ()

basicUnsafeSparseRead :: PrimMonad m => MArray Native rep lay locality rank (PrimState m) el -> Index rank -> m (Maybe el)

class RectilinearArray marr rank a | marr -> rank where

Associated Types

type MutableRectilinearOrientation marr :: *

MutableRectilinearOrientation marr should equal Row or Column for any sane choice of instance, because every MutableRectilinear instance will have a notion of what the nominal major axix will be. The intended use case is side condition constraints like MutableRectilinearOrientation marr~Row)=> marr -> b for operations where majorAxix projections are correct only for Row major formats. Such as Row based forward/backward substitution (triangular solvers)

type MutableArrayDownRank marr (st :: *) a

type MutableInnerContigArray (marr :: * -> * -> *) st a

MutableInnerContigArray is the "meet" (minimum) of the locality level of marr and InnerContiguous. Thus both Contiguous and InnerContiguous are made InnerContiguous, and Strided stays Strided for now this makes sense to have in the MutableRectilinear class, though that may change. This could also be thought of as being the GLB (greatest lower bound) on locality

Methods

basicMutableSliceMajorAxis :: PrimMonad m => marr (PrimState m) a -> (Int, Int) -> m (marr (PrimState m) a)

basicSliceMajorAxis arr (x,y) returns the sub array of the same rank, with the outermost (ie major axis) dimension of arr restricted to the (x,y) is an inclusive interval, MUST satisfy x<y , and be a valid subinterval of the major axis of arr.

basicMutableProjectMajorAxis :: PrimMonad m => marr (PrimState m) a -> Int -> m (MutableArrayDownRank marr (PrimState m) a)

basicMutableSlice :: PrimMonad m => marr (PrimState m) a -> Index rank -> Index rank -> m (MutableInnerContigArray marr (PrimState m) a)

basicMutableSlice arr ix1 ix2 picks out the (hyper) rectangle in dimension rank where ix1 is the minimal corner and ix2

class DenseArray marr rank a => DenseArrayBuilder marr rank a where

Methods

basicUnsafeNew :: PrimMonad m => Index rank -> m (marr (PrimState m) a)

basicUnsafeReplicate :: PrimMonad m => Index rank -> a -> m (marr (PrimState m) a)

class (Array marr rank a, PureDenseArray (ArrPure marr) rank a) => DenseArray marr rank a | marr -> rank where

Methods

basicIndexInBounds :: marr st a -> Index rank -> Bool

for Dense arrays, it is always easy to check if a given index is valid. this operation better have O(1) complexity or else!

basicUnsafeDenseRead :: PrimMonad m => marr (PrimState m) a -> Index rank -> m a

Yield the element at the given position. This method should not be called directly, use unsafeRead instead.

basicUnsafeDenseWrite :: PrimMonad m => marr (PrimState m) a -> Index rank -> a -> m ()

Replace the element at the given position. This method should not be called directly, use unsafeWrite instead.

basicNextAddress :: marr st a -> Address -> Address

gives the next valid logical address undefined on invalid addresses and the greatest valid address. Note that for invalid addresses in between minAddress and maxAddress, will return the next valid address.

basicNextIndex :: marr st a -> Index rank -> Index rank

gives the next valid array index undefined on invalid indices and the greatest valid index

data Boxed

Boxed is the type index for Buffers that use the boxed data structure Vector as the underlying storage representation.

Instances

Data Boxed

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxed -> c Boxed

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed

toConstr :: Boxed -> Constr

dataTypeOf :: Boxed -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed)

gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r

gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed

Functor (BufferPure Boxed)

Defined in Numerical.Array.Storage

Methods

fmap :: (a -> b) -> BufferPure Boxed a -> BufferPure Boxed b

(<$) :: a -> BufferPure Boxed b -> BufferPure Boxed a

Foldable (BufferPure Boxed)

Defined in Numerical.Array.Storage

Methods

fold :: Monoid m => BufferPure Boxed m -> m

foldMap :: Monoid m => (a -> m) -> BufferPure Boxed a -> m

foldr :: (a -> b -> b) -> b -> BufferPure Boxed a -> b

foldr' :: (a -> b -> b) -> b -> BufferPure Boxed a -> b

foldl :: (b -> a -> b) -> b -> BufferPure Boxed a -> b

foldl' :: (b -> a -> b) -> b -> BufferPure Boxed a -> b

foldr1 :: (a -> a -> a) -> BufferPure Boxed a -> a

foldl1 :: (a -> a -> a) -> BufferPure Boxed a -> a

toList :: BufferPure Boxed a -> [a]

null :: BufferPure Boxed a -> Bool

length :: BufferPure Boxed a -> Int

elem :: Eq a => a -> BufferPure Boxed a -> Bool

maximum :: Ord a => BufferPure Boxed a -> a

minimum :: Ord a => BufferPure Boxed a -> a

sum :: Num a => BufferPure Boxed a -> a

product :: Num a => BufferPure Boxed a -> a

Traversable (BufferPure Boxed)

Defined in Numerical.Array.Storage

Methods

traverse :: Applicative f => (a -> f b) -> BufferPure Boxed a -> f (BufferPure Boxed b)

sequenceA :: Applicative f => BufferPure Boxed (f a) -> f (BufferPure Boxed a)

mapM :: Monad m => (a -> m b) -> BufferPure Boxed a -> m (BufferPure Boxed b)

sequence :: Monad m => BufferPure Boxed (m a) -> m (BufferPure Boxed a)

Vector Vector a => Vector (BufferPure Boxed) a

Defined in Numerical.Array.Storage

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable (BufferPure Boxed) (PrimState m) a -> m (BufferPure Boxed a)

basicUnsafeThaw :: PrimMonad m => BufferPure Boxed a -> m (Mutable (BufferPure Boxed) (PrimState m) a)

basicLength :: BufferPure Boxed a -> Int

basicUnsafeSlice :: Int -> Int -> BufferPure Boxed a -> BufferPure Boxed a

basicUnsafeIndexM :: Monad m => BufferPure Boxed a -> Int -> m a

basicUnsafeCopy :: PrimMonad m => Mutable (BufferPure Boxed) (PrimState m) a -> BufferPure Boxed a -> m ()

elemseq :: BufferPure Boxed a -> a -> b -> b

MVector MVector elem => MVector (BufferMut Boxed) elem

Defined in Numerical.Array.Storage

Methods

basicLength :: BufferMut Boxed s elem -> Int

basicUnsafeSlice :: Int -> Int -> BufferMut Boxed s elem -> BufferMut Boxed s elem

basicOverlaps :: BufferMut Boxed s elem -> BufferMut Boxed s elem -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (BufferMut Boxed (PrimState m) elem)

basicInitialize :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> elem -> m (BufferMut Boxed (PrimState m) elem)

basicUnsafeRead :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> Int -> m elem

basicUnsafeWrite :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> Int -> elem -> m ()

basicClear :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> m ()

basicSet :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> elem -> m ()

basicUnsafeCopy :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> BufferMut Boxed (PrimState m) elem -> m ()

basicUnsafeMove :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> BufferMut Boxed (PrimState m) elem -> m ()

basicUnsafeGrow :: PrimMonad m => BufferMut Boxed (PrimState m) elem -> Int -> m (BufferMut Boxed (PrimState m) elem)

Data elem => Data (BufferPure Boxed elem)

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BufferPure Boxed elem -> c (BufferPure Boxed elem)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BufferPure Boxed elem)

toConstr :: BufferPure Boxed elem -> Constr

dataTypeOf :: BufferPure Boxed elem -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BufferPure Boxed elem))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BufferPure Boxed elem))

gmapT :: (forall b. Data b => b -> b) -> BufferPure Boxed elem -> BufferPure Boxed elem

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Boxed elem -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Boxed elem -> r

gmapQ :: (forall d. Data d => d -> u) -> BufferPure Boxed elem -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BufferPure Boxed elem -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BufferPure Boxed elem -> m (BufferPure Boxed elem)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Boxed elem -> m (BufferPure Boxed elem)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Boxed elem -> m (BufferPure Boxed elem)

Show elem => Show (BufferPure Boxed elem)

Defined in Numerical.Array.Storage

Methods

showsPrec :: Int -> BufferPure Boxed elem -> ShowS

show :: BufferPure Boxed elem -> String

showList :: [BufferPure Boxed elem] -> ShowS

Generic (BufferPure Boxed elem)

Defined in Numerical.Array.Storage

Associated Types

type Rep (BufferPure Boxed elem) :: Type -> Type

Methods

from :: BufferPure Boxed elem -> Rep (BufferPure Boxed elem) x

to :: Rep (BufferPure Boxed elem) x -> BufferPure Boxed elem

data BufferMut Boxed st elem

Defined in Numerical.Array.Storage

data BufferMut Boxed st elem = BoxedBufferMut (MVector st elem)

data BufferPure Boxed elem

Defined in Numerical.Array.Storage

data BufferPure Boxed elem = BoxedBuffer (Vector elem)

type Rep (BufferPure Boxed elem)

Defined in Numerical.Array.Storage

type Rep (BufferPure Boxed elem) = D1 (MetaData "BufferPure" "Numerical.Array.Storage" "numerical-0.0.0.0-G1yWw4Hx7O95VnU5FU3zyO" True) (C1 (MetaCons "BoxedBuffer" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Vector elem))))

data Unboxed

Unboxed is the type index for Buffers that use the unboxed data structure Vector as the underlying storage representation.

Instances

Data Unboxed

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unboxed -> c Unboxed

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Unboxed

toConstr :: Unboxed -> Constr

dataTypeOf :: Unboxed -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Unboxed)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unboxed)

gmapT :: (forall b. Data b => b -> b) -> Unboxed -> Unboxed

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unboxed -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unboxed -> r

gmapQ :: (forall d. Data d => d -> u) -> Unboxed -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unboxed -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unboxed -> m Unboxed

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unboxed -> m Unboxed

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unboxed -> m Unboxed

Vector Vector a => Vector (BufferPure Unboxed) a

Defined in Numerical.Array.Storage

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable (BufferPure Unboxed) (PrimState m) a -> m (BufferPure Unboxed a)

basicUnsafeThaw :: PrimMonad m => BufferPure Unboxed a -> m (Mutable (BufferPure Unboxed) (PrimState m) a)

basicLength :: BufferPure Unboxed a -> Int

basicUnsafeSlice :: Int -> Int -> BufferPure Unboxed a -> BufferPure Unboxed a

basicUnsafeIndexM :: Monad m => BufferPure Unboxed a -> Int -> m a

basicUnsafeCopy :: PrimMonad m => Mutable (BufferPure Unboxed) (PrimState m) a -> BufferPure Unboxed a -> m ()

elemseq :: BufferPure Unboxed a -> a -> b -> b

MVector MVector elem => MVector (BufferMut Unboxed) elem

Defined in Numerical.Array.Storage

Methods

basicLength :: BufferMut Unboxed s elem -> Int

basicUnsafeSlice :: Int -> Int -> BufferMut Unboxed s elem -> BufferMut Unboxed s elem

basicOverlaps :: BufferMut Unboxed s elem -> BufferMut Unboxed s elem -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (BufferMut Unboxed (PrimState m) elem)

basicInitialize :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> elem -> m (BufferMut Unboxed (PrimState m) elem)

basicUnsafeRead :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> Int -> m elem

basicUnsafeWrite :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> Int -> elem -> m ()

basicClear :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> m ()

basicSet :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> elem -> m ()

basicUnsafeCopy :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> BufferMut Unboxed (PrimState m) elem -> m ()

basicUnsafeMove :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> BufferMut Unboxed (PrimState m) elem -> m ()

basicUnsafeGrow :: PrimMonad m => BufferMut Unboxed (PrimState m) elem -> Int -> m (BufferMut Unboxed (PrimState m) elem)

(Data elem, Unbox elem) => Data (BufferPure Unboxed elem)

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BufferPure Unboxed elem -> c (BufferPure Unboxed elem)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BufferPure Unboxed elem)

toConstr :: BufferPure Unboxed elem -> Constr

dataTypeOf :: BufferPure Unboxed elem -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BufferPure Unboxed elem))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BufferPure Unboxed elem))

gmapT :: (forall b. Data b => b -> b) -> BufferPure Unboxed elem -> BufferPure Unboxed elem

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Unboxed elem -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Unboxed elem -> r

gmapQ :: (forall d. Data d => d -> u) -> BufferPure Unboxed elem -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BufferPure Unboxed elem -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BufferPure Unboxed elem -> m (BufferPure Unboxed elem)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Unboxed elem -> m (BufferPure Unboxed elem)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Unboxed elem -> m (BufferPure Unboxed elem)

(Show elem, Unbox elem) => Show (BufferPure Unboxed elem)

Defined in Numerical.Array.Storage

Methods

showsPrec :: Int -> BufferPure Unboxed elem -> ShowS

show :: BufferPure Unboxed elem -> String

showList :: [BufferPure Unboxed elem] -> ShowS

Generic (BufferPure Unboxed elem)

Defined in Numerical.Array.Storage

Associated Types

type Rep (BufferPure Unboxed elem) :: Type -> Type

Methods

from :: BufferPure Unboxed elem -> Rep (BufferPure Unboxed elem) x

to :: Rep (BufferPure Unboxed elem) x -> BufferPure Unboxed elem

data BufferMut Unboxed st elem

Defined in Numerical.Array.Storage

data BufferMut Unboxed st elem = UnboxedBufferMut (MVector st elem)

data BufferPure Unboxed elem

Defined in Numerical.Array.Storage

data BufferPure Unboxed elem = UnboxedBuffer (Vector elem)

type Rep (BufferPure Unboxed elem)

Defined in Numerical.Array.Storage

type Rep (BufferPure Unboxed elem) = D1 (MetaData "BufferPure" "Numerical.Array.Storage" "numerical-0.0.0.0-G1yWw4Hx7O95VnU5FU3zyO" True) (C1 (MetaCons "UnboxedBuffer" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Vector elem))))

data Stored

Stored is the type index for Buffers that use the Storable for values, in pinned byte array buffers, provided by Storable

Instances

Data Stored

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stored -> c Stored

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stored

toConstr :: Stored -> Constr

dataTypeOf :: Stored -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stored)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stored)

gmapT :: (forall b. Data b => b -> b) -> Stored -> Stored

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stored -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stored -> r

gmapQ :: (forall d. Data d => d -> u) -> Stored -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stored -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stored -> m Stored

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stored -> m Stored

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stored -> m Stored

Storable a => Vector (BufferPure Stored) a

Defined in Numerical.Array.Storage

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable (BufferPure Stored) (PrimState m) a -> m (BufferPure Stored a)

basicUnsafeThaw :: PrimMonad m => BufferPure Stored a -> m (Mutable (BufferPure Stored) (PrimState m) a)

basicLength :: BufferPure Stored a -> Int

basicUnsafeSlice :: Int -> Int -> BufferPure Stored a -> BufferPure Stored a

basicUnsafeIndexM :: Monad m => BufferPure Stored a -> Int -> m a

basicUnsafeCopy :: PrimMonad m => Mutable (BufferPure Stored) (PrimState m) a -> BufferPure Stored a -> m ()

elemseq :: BufferPure Stored a -> a -> b -> b

Storable elem => MVector (BufferMut Stored) elem

Defined in Numerical.Array.Storage

Methods

basicLength :: BufferMut Stored s elem -> Int

basicUnsafeSlice :: Int -> Int -> BufferMut Stored s elem -> BufferMut Stored s elem

basicOverlaps :: BufferMut Stored s elem -> BufferMut Stored s elem -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (BufferMut Stored (PrimState m) elem)

basicInitialize :: PrimMonad m => BufferMut Stored (PrimState m) elem -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> elem -> m (BufferMut Stored (PrimState m) elem)

basicUnsafeRead :: PrimMonad m => BufferMut Stored (PrimState m) elem -> Int -> m elem

basicUnsafeWrite :: PrimMonad m => BufferMut Stored (PrimState m) elem -> Int -> elem -> m ()

basicClear :: PrimMonad m => BufferMut Stored (PrimState m) elem -> m ()

basicSet :: PrimMonad m => BufferMut Stored (PrimState m) elem -> elem -> m ()

basicUnsafeCopy :: PrimMonad m => BufferMut Stored (PrimState m) elem -> BufferMut Stored (PrimState m) elem -> m ()

basicUnsafeMove :: PrimMonad m => BufferMut Stored (PrimState m) elem -> BufferMut Stored (PrimState m) elem -> m ()

basicUnsafeGrow :: PrimMonad m => BufferMut Stored (PrimState m) elem -> Int -> m (BufferMut Stored (PrimState m) elem)

(Data elem, Storable elem) => Data (BufferPure Stored elem)

Defined in Numerical.Array.Storage

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BufferPure Stored elem -> c (BufferPure Stored elem)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BufferPure Stored elem)

toConstr :: BufferPure Stored elem -> Constr

dataTypeOf :: BufferPure Stored elem -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BufferPure Stored elem))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BufferPure Stored elem))

gmapT :: (forall b. Data b => b -> b) -> BufferPure Stored elem -> BufferPure Stored elem

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Stored elem -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufferPure Stored elem -> r

gmapQ :: (forall d. Data d => d -> u) -> BufferPure Stored elem -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BufferPure Stored elem -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BufferPure Stored elem -> m (BufferPure Stored elem)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Stored elem -> m (BufferPure Stored elem)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BufferPure Stored elem -> m (BufferPure Stored elem)

(Show elem, Storable elem) => Show (BufferPure Stored elem)

Defined in Numerical.Array.Storage

Methods

showsPrec :: Int -> BufferPure Stored elem -> ShowS

show :: BufferPure Stored elem -> String

showList :: [BufferPure Stored elem] -> ShowS

Generic (BufferPure Stored elem)

Defined in Numerical.Array.Storage

Associated Types

type Rep (BufferPure Stored elem) :: Type -> Type

Methods

from :: BufferPure Stored elem -> Rep (BufferPure Stored elem) x

to :: Rep (BufferPure Stored elem) x -> BufferPure Stored elem

data BufferMut Stored st elem

Defined in Numerical.Array.Storage

data BufferMut Stored st elem = StorableBufferMut (MVector st elem)

data BufferPure Stored elem

Defined in Numerical.Array.Storage

data BufferPure Stored elem = StorableBuffer (Vector elem)

type Rep (BufferPure Stored elem)

Defined in Numerical.Array.Storage

type Rep (BufferPure Stored elem) = D1 (MetaData "BufferPure" "Numerical.Array.Storage" "numerical-0.0.0.0-G1yWw4Hx7O95VnU5FU3zyO" True) (C1 (MetaCons "StorableBuffer" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Vector elem))))

module Numerical.Array.Shape