|
Data.Array.Base | Portability | non-portable (MPTCs, uses Control.Monad.ST) | Stability | experimental | Maintainer | libraries@haskell.org |
|
|
|
Description |
Basis for IArray and MArray. Not intended for external consumption;
use IArray or MArray instead.
|
|
Synopsis |
|
class IArray a e where | | | safeRangeSize :: Ix i => (i, i) -> Int | | safeIndex :: Ix i => (i, i) -> Int -> i -> Int | | unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e) | | unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e) | | unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e) | | array :: (IArray a e, Ix i) => (i, i) -> [(i, e)] -> a i e | | listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e | | listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e) | | listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e) | | type ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e | | (!) :: (IArray a e, Ix i) => a i e -> i -> e | | indices :: (IArray a e, Ix i) => a i e -> [i] | | elems :: (IArray a e, Ix i) => a i e -> [e] | | assocs :: (IArray a e, Ix i) => a i e -> [(i, e)] | | accumArray :: (IArray a e, Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e | | (//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e | | accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e | | amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e | | ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e | | data UArray i e = UArray !i !i !Int ByteArray# | | unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e) | | unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e) | | unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e) | | unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e) | | unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e) | | eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool | | cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering | | cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering | | showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS | | arrEleBottom :: a | | class Monad m => MArray a e m where | | | newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) | | readArray :: (MArray a e m, Ix i) => a i e -> i -> m e | | writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m () | | getElems :: (MArray a e m, Ix i) => a i e -> m [e] | | getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)] | | mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e) | | mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e) | | data STUArray s i a = STUArray !i !i !Int (MutableByteArray# s) | | unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e) | | bOOL_WORD_SCALE :: Int# -> Int# | | bOOL_INDEX :: Int# -> Int# | | bOOL_NOT_BIT :: Int# -> Word# | | freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) | | freezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e) | | memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a) | | unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) | | thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) | | thawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e) | | memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a) | | unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) | | unsafeThawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e) | | castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b) |
|
|
Documentation |
|
class IArray a e where |
Class of immutable array types.
An array type has the form (a i e) where a is the array type
constructor (kind * -> * -> *), i is the index type (a member of
the class Ix), and e is the element type. The IArray class is
parameterised over both a and e, so that instances specialised to
certain element types can be defined.
| | Methods | bounds :: Ix i => a i e -> (i, i) | Extracts the bounds of an immutable array
| | numElements :: Ix i => a i e -> Int | | unsafeArray :: Ix i => (i, i) -> [(Int, e)] -> a i e | | unsafeAt :: Ix i => a i e -> Int -> e | | unsafeReplace :: Ix i => a i e -> [(Int, e)] -> a i e | | unsafeAccum :: Ix i => (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e | | unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e |
| | Instances | |
|
|
safeRangeSize :: Ix i => (i, i) -> Int |
|
safeIndex :: Ix i => (i, i) -> Int -> i -> Int |
|
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e) |
|
unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e) |
|
unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e) |
|
array |
:: (IArray a e, Ix i) | | => (i, i) | bounds of the array: (lowest,highest)
| -> [(i, e)] | list of associations
| -> a i e | | Constructs an immutable array from a pair of bounds and a list of
initial associations.
The bounds are specified as a pair of the lowest and highest bounds in
the array respectively. For example, a one-origin vector of length 10
has bounds (1,10), and a one-origin 10 by 10 matrix has bounds
((1,1),(10,10)).
An association is a pair of the form (i,x), which defines the value of
the array at index i to be x. The array is undefined if any index
in the list is out of bounds. If any two associations in the list have
the same index, the value at that index is implementation-dependent.
(In GHC, the last value specified for that index is used.
Other implementations will also do this for unboxed arrays, but Haskell
98 requires that for Data.Array.Array the value at such indices is bottom.)
Because the indices must be checked for these errors, array is
strict in the bounds argument and in the indices of the association
list. Whether array is strict or non-strict in the elements depends
on the array type: Data.Array.Array is a non-strict array type, but
all of the Data.Array.Unboxed.UArray arrays are strict. Thus in a
non-strict array, recurrences such as the following are possible:
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
Not every index within the bounds of the array need appear in the
association list, but the values associated with indices that do not
appear will be undefined.
If, in any dimension, the lower bound is greater than the upper bound,
then the array is legal, but empty. Indexing an empty array always
gives an array-bounds error, but bounds still yields the bounds with
which the array was constructed.
|
|
|
listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e |
Constructs an immutable array from a list of initial elements.
The list gives the elements of the array in ascending order
beginning with the lowest index.
|
|
listArrayST :: Ix i => (i, i) -> [e] -> ST s (STArray s i e) |
|
listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [e] -> ST s (STUArray s i e) |
|
type ListUArray e = forall i. Ix i => (i, i) -> [e] -> UArray i e |
|
(!) :: (IArray a e, Ix i) => a i e -> i -> e |
Returns the element of an immutable array at the specified index.
|
|
indices :: (IArray a e, Ix i) => a i e -> [i] |
Returns a list of all the valid indices in an array.
|
|
elems :: (IArray a e, Ix i) => a i e -> [e] |
Returns a list of all the elements of an array, in the same order
as their indices.
|
|
assocs :: (IArray a e, Ix i) => a i e -> [(i, e)] |
Returns the contents of an array as a list of associations.
|
|
accumArray |
:: (IArray a e, Ix i) | | => e -> e' -> e | An accumulating function
| -> e | A default element
| -> (i, i) | The bounds of the array
| -> [(i, e')] | List of associations
| -> a i e | Returns: the array
| Constructs an immutable array from a list of associations. Unlike
array, the same index is allowed to occur multiple times in the list
of associations; an accumulating function is used to combine the
values of elements with the same index.
For example, given a list of values of some index type, hist produces
a histogram of the number of occurrences of each index within a
specified range:
hist :: (Ix a, Num b) => (a,a) -> [a] -> Array a b
hist bnds is = accumArray (+) 0 bnds [(i, 1) | i\<-is, inRange bnds i]
|
|
|
(//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e |
Takes an array and a list of pairs and returns an array identical to
the left argument except that it has been updated by the associations
in the right argument. For example, if m is a 1-origin, n by n matrix,
then m//[((i,i), 0) | i <- [1..n]] is the same matrix, except with
the diagonal zeroed.
As with the array function, if any two associations in the list have
the same index, the value at that index is implementation-dependent.
(In GHC, the last value specified for that index is used.
Other implementations will also do this for unboxed arrays, but Haskell
98 requires that for Data.Array.Array the value at such indices is bottom.)
For most array types, this operation is O(n) where n is the size
of the array. However, the Data.Array.Diff.DiffArray type provides
this operation with complexity linear in the number of updates.
|
|
accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e |
accum f takes an array and an association list and accumulates pairs
from the list into the array with the accumulating function f. Thus
accumArray can be defined using accum:
accumArray f z b = accum f (array b [(i, z) | i \<- range b])
|
|
amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e |
Returns a new array derived from the original array by applying a
function to each of the elements.
|
|
ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e |
Returns a new array derived from the original array by applying a
function to each of the indices.
|
|
data UArray i e |
Arrays with unboxed elements. Instances of IArray are provided
for UArray with certain element types (Int, Float, Char,
etc.; see the UArray class for a full list).
A UArray will generally be more efficient (in terms of both time
and space) than the equivalent Data.Array.Array with the same
element type. However, UArray is strict in its elements - so
don't use UArray if you require the non-strictness that
Data.Array.Array provides.
Because the IArray interface provides operations overloaded on
the type of the array, it should be possible to just change the
array type being used by a program from say Array to UArray to
get the benefits of unboxed arrays (don't forget to import
Data.Array.Unboxed instead of Data.Array).
| Constructors | UArray !i !i !Int ByteArray# | |
| Instances | |
|
|
unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (i, i) -> [(Int, e)] -> e -> ST s (UArray i e) |
|
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e) |
|
unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i) => UArray i e -> [(Int, e)] -> ST s (UArray i e) |
|
unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e) |
|
unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i) => (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e) |
|
eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool |
|
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering |
|
cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering |
|
showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS |
|
arrEleBottom :: a |
|
class Monad m => MArray a e m where |
Class of mutable array types.
An array type has the form (a i e) where a is the array type
constructor (kind * -> * -> *), i is the index type (a member of
the class Ix), and e is the element type.
The MArray class is parameterised over both a and e (so that
instances specialised to certain element types can be defined, in the
same way as for IArray), and also over the type of the monad, m,
in which the mutable array will be manipulated.
| | Methods | getBounds :: Ix i => a i e -> m (i, i) | Returns the bounds of the array
| | getNumElements :: Ix i => a i e -> m Int | Returns the number of elements in the array
| | newArray :: Ix i => (i, i) -> e -> m (a i e) | Builds a new array, with every element initialised to the supplied
value.
| | newArray_ :: Ix i => (i, i) -> m (a i e) | Builds a new array, with every element initialised to an
undefined value. In a monadic context in which operations must
be deterministic (e.g. the ST monad), the array elements are
initialised to a fixed but undefined value, such as zero.
| | unsafeNewArray_ :: Ix i => (i, i) -> m (a i e) | Builds a new array, with every element initialised to an undefined
value.
| | unsafeRead :: Ix i => a i e -> Int -> m e | | unsafeWrite :: Ix i => a i e -> Int -> e -> m () |
| | Instances | |
|
|
newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) |
Constructs a mutable array from a list of initial elements.
The list gives the elements of the array in ascending order
beginning with the lowest index.
|
|
readArray :: (MArray a e m, Ix i) => a i e -> i -> m e |
Read an element from a mutable array
|
|
writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m () |
Write an element in a mutable array
|
|
getElems :: (MArray a e m, Ix i) => a i e -> m [e] |
Return a list of all the elements of a mutable array
|
|
getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)] |
Return a list of all the associations of a mutable array, in
index order.
|
|
mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e) |
Constructs a new array derived from the original array by applying a
function to each of the elements.
|
|
mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e) |
Constructs a new array derived from the original array by applying a
function to each of the indices.
|
|
data STUArray s i a |
A mutable array with unboxed elements, that can be manipulated in
the ST monad. The type arguments are as follows:
- s: the state variable argument for the ST type
- i: the index type of the array (should be an instance of Ix)
- e: the element type of the array. Only certain element types
are supported.
An STUArray will generally be more efficient (in terms of both time
and space) than the equivalent boxed version (Data.Array.ST.STArray)
with the same element type. However, STUArray is strict in its
elements - so -- don't use STUArray if you require the
non-strictness that Data.Array.ST.STArray provides.
| Constructors | STUArray !i !i !Int (MutableByteArray# s) | |
| Instances | |
|
|
unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e) |
|
bOOL_WORD_SCALE :: Int# -> Int# |
|
bOOL_INDEX :: Int# -> Int# |
|
bOOL_NOT_BIT :: Int# -> Word# |
|
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) |
Converts a mutable array (any instance of MArray) to an
immutable array (any instance of IArray) by taking a complete
copy of it.
|
|
freezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e) |
|
memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a) |
|
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) |
|
thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) |
Converts an immutable array (any instance of IArray) into a
mutable array (any instance of MArray) by taking a complete copy
of it.
|
|
thawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e) |
|
memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a) |
|
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) |
|
unsafeThawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e) |
|
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b) |
Casts an STUArray with one element type into one with a
different element type. All the elements of the resulting array
are undefined (unless you know what you're doing...).
|
|
Produced by Haddock version 2.2.2 |