Data.Array.Base
| Авторское право | (c) The University of Glasgow 2001 |
|---|---|
| Лицензия | в стиле BSD (см. файл libraries/base/LICENSE) |
| Сопровождающий | libraries@haskell.org |
| Стабильность | экспериментальный |
| Переносимость | непереносимый (MPTCs, используется Control.Monad.ST) |
| Безопасный Haskell | Нет |
| Язык | Haskell2010 |
Описание
Основа для IArray и MArray. Не предназначен для внешнего использования; используйте вместо него IArray или MArray.
ПРЕДУПРЕЖДЕНИЕ
Этот модуль считается внутренним.
Политика версионирования пакетов не применяется.
Содержимое этого модуля может измениться любым образом и без предупреждения между минорными версиями этого пакета.
От авторов, импортирующих этот модуль, ожидается пристальное отслеживание его разработки.
class IArray (a :: Type -> Type -> Type) e where Исходный код
Класс неизменяемых типов массивов.
Тип массива имеет вид (a i e), где a — конструктор типа массива (kind * -> * -> *), i — тип индекса (член класса Ix), а e — тип элемента. Класс IArray параметризован как a, так и e, что позволяет определять экземпляры, специализированные для определённых типов элементов.
Минимальное полное определение
Методы
bounds :: Ix i => a i e -> (i, i) Исходный код
Извлекает границы неизменяемого массива
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 Исходный код
Экземпляры
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) Источник
Аргументы
| :: (IArray a e, Ix i) | |
| => (i, i) | границы массива: (наименьшая, наибольшая) |
| -> [(i, e)] | список ассоциаций |
| -> a i e |
Создаёт неизменяемый массив по паре границ и списку начальных ассоциаций.
Границы задаются парой, состоящей соответственно из наименьшей и наибольшей границ массива. Например, вектор длины 10 с нумерацией от единицы имеет границы (1,10), а матрица 10 на 10 с нумерацией от единицы — границы ((1,1),(10,10)).
Ассоциация — это пара вида (i,x), которая задаёт значение массива по индексу i как x. Массив не определён, если какой-либо индекс в списке выходит за границы. Если в списке есть две ассоциации с одинаковым индексом, значение по этому индексу зависит от реализации. (В GHC используется последнее указанное значение для этого индекса. Другие реализации также поступают так для массивов без упаковки, однако Haskell 98 требует, чтобы для Array значением по таким индексам было bottom.)
Поскольку индексы необходимо проверять на наличие этих ошибок, array является строгой по аргументу границ и индексам списка ассоциаций. Строгой или нестрогой будет array по элементам, зависит от типа массива: Array — нестрогий тип массива, но все массивы UArray являются строгими. Поэтому в нестрогом массиве возможны такие рекуррентные определения:
a = array (1,100) ((1,1) : [(i, i * a!(i-1)) | i \<- [2..100]])
В списке ассоциаций необязательно должны присутствовать все индексы в границах массива, однако значения для отсутствующих индексов не определены.
Если в каком-либо измерении нижняя граница больше верхней, массив допустим, но пуст. Индексация пустого массива всегда вызывает ошибку выхода за границы, однако bounds по-прежнему возвращает границы, с которыми был создан массив.
listArray :: (IArray a e, Ix i) => (i, i) -> [e] -> a i e Источник
Создаёт неизменяемый массив из списка начальных элементов. Элементы массива задаются списком в порядке возрастания индексов, начиная с наименьшего индекса.
genArray :: (IArray a e, Ix i) => (i, i) -> (i -> e) -> a i e Источник
Создаёт неизменяемый массив с помощью функции-генератора.
Начиная с: array-0.5.6.0
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 Источник
Возвращает элемент неизменяемого массива по указанному индексу или вызывает исключение, если индекс выходит за границы.
(!?) :: (IArray a e, Ix i) => a i e -> i -> Maybe e Источник
Возвращает Just элемент неизменяемого массива по указанному индексу или Nothing, если индекс выходит за границы.
Начиная с: array-0.5.6.0
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)] Источник
Возвращает содержимое массива в виде списка ассоциаций.
Аргументы
| :: (IArray a e, Ix i) | |
| => (e -> e' -> e) | Функция накопления |
| -> e | Элемент по умолчанию |
| -> (i, i) | Границы массива |
| -> [(i, e')] | Список ассоциаций |
| -> a i e | Возвращает: массив |
Создаёт неизменяемый массив из списка ассоциаций. В отличие от array, один и тот же индекс может встречаться в списке ассоциаций несколько раз; для объединения значений элементов с одинаковым индексом используется функция накопления.
Например, для заданного списка значений некоторого типа индексов функция hist строит гистограмму количества вхождений каждого индекса в указанном диапазоне:
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 Источник
Принимает массив и список пар и возвращает массив, идентичный левому аргументу, но обновлённый ассоциациями из правого аргумента. Например, если m — матрица n на n с нумерацией от единицы, то m//[((i,i), 0) | i <- [1..n]] — та же матрица, но с нулями на диагонали.
Как и для функции array, если в списке есть две ассоциации с одинаковым индексом, значение по этому индексу зависит от реализации. (В GHC используется последнее указанное значение для этого индекса. Другие реализации также поступают так для массивов без упаковки, однако Haskell 98 требует, чтобы для Array значением по таким индексам было bottom.)
Для большинства типов массивов сложность этой операции составляет O(n), где n — размер массива. Однако пакет diffarray предоставляет тип массива, для которого сложность этой операции линейна относительно количества обновлений.
accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e Источник
accum f принимает массив и список ассоциаций и накапливает пары из списка в массиве с помощью функции накопления f. Таким образом, accumArray можно определить с помощью 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 Источник
Возвращает новый массив, полученный из исходного применением функции к каждому элементу.
ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e Источник
Возвращает новый массив, полученный из исходного применением функции к каждому индексу.
foldrArray :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b Источник
Ленивое правоассоциативное свёртывание.
Начиная с: array-0.5.8.0
foldlArray' :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b Источник
Строгое накапливающее левоассоциативное свёртывание.
Начиная с: array-0.5.8.0
foldlArray :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b Источник
Ленивое левоассоциативное свёртывание.
Начиная с: array-0.5.8.0
foldrArray' :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b Источник
Строгое накапливающее правоассоциативное свёртывание.
Начиная с: array-0.5.8.0
traverseArray_ :: (IArray a e, Ix i, Applicative f) => (e -> f b) -> a i e -> f () Источник
Преобразует элементы в аппликативные действия, выполняет их последовательно слева направо и отбрасывает результаты.
Начиная с: array-0.5.8.0
forArray_ :: (IArray a e, Ix i, Applicative f) => a i e -> (e -> f b) -> f () Источник
forArray_ — это traverseArray_ с переставленными аргументами.
Начиная с: array-0.5.8.0
foldlArrayM' :: (IArray a e, Ix i, Monad m) => (b -> e -> m b) -> b -> a i e -> m b Источник
Строгое накапливающее левоассоциативное монадическое свёртывание.
Начиная с: array-0.5.8.0
foldrArrayM' :: (IArray a e, Ix i, Monad m) => (e -> b -> m b) -> b -> a i e -> m b Источник
Строгое накапливающее правоассоциативное монадическое свёртывание.
Начиная с: array-0.5.8.0
Массивы с элементами без упаковки. Экземпляры IArray предоставляются для UArray с некоторыми типами элементов (Int, Float, Char и т. д.; полный список см. в классе UArray).
Как правило, UArray будет эффективнее (и по времени, и по памяти), чем соответствующий Array с тем же типом элементов. Однако UArray является строгим по элементам — поэтому не используйте UArray, если вам нужна нестрогость, обеспечиваемая Array.
Поскольку интерфейс IArray предоставляет операции, перегруженные по типу массива, достаточно изменить используемый программой тип массива, например с Array на UArray, чтобы воспользоваться преимуществами массивов без упаковки (не забудьте импортировать Data.Array.Unboxed вместо Data.Array).
Конструкторы
| 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 Исходный код
readIArray :: (IArray a e, Ix i, Read i, Read e) => ReadPrec (a i e) Исходный код
nullStablePtr :: StablePtr a Исходный код
arrEleBottom :: a Исходный код
class Monad m => MArray (a :: Type -> Type -> Type) e (m :: Type -> Type) where Исходный код
Класс типов изменяемых массивов.
Тип массива имеет вид (a i e), где a — конструктор типа массива (вид * -> * -> *), i — тип индекса (принадлежащий классу типов Ix), а e — тип элемента.
Класс MArray параметризован как по a, так и по e (чтобы можно было определять экземпляры, специализированные для определённых типов элементов, как и для IArray), а также по типу монады m, в которой будут выполняться операции с изменяемым массивом.
Минимальное полное определение
getBounds, getNumElements, (newArray | unsafeNewArray_), unsafeRead, unsafeWrite
Методы
getBounds :: Ix i => a i e -> m (i, i) Исходный код
Возвращает границы массива (наименьший, наибольший).
getNumElements :: Ix i => a i e -> m Int Исходный код
Возвращает количество элементов в массиве.
newArray :: Ix i => (i, i) -> e -> m (a i e) Исходный код
Создаёт новый массив, инициализируя каждый элемент переданным значением. Первый и второй элементы кортежа задают соответственно наименьший и наибольший индексы.
newArray_ :: Ix i => (i, i) -> m (a i e) Исходный код
Создаёт новый массив, инициализируя каждый элемент неопределённым значением. В монадическом контексте, в котором операции должны быть детерминированными (например, в монаде ST), элементы массива инициализируются фиксированным, но неопределённым значением, например нулём. Первый и второй элементы кортежа задают соответственно наименьший и наибольший индексы.
unsafeNewArray_ :: Ix i => (i, i) -> m (a i e) Исходный код
Создаёт новый массив, инициализируя каждый элемент неопределённым значением. Первый и второй элементы кортежа задают соответственно наименьший и наибольший индексы.
unsafeRead :: Ix i => a i e -> Int -> m e Исходный код
unsafeWrite :: Ix i => a i e -> Int -> e -> m () Исходный код
Экземпляры
newListArray :: (MArray a e m, Ix i) => (i, i) -> [e] -> m (a i e) Исходный код
Создаёт изменяемый массив из списка начальных элементов. Список задаёт элементы массива в порядке возрастания, начиная с наименьшего индекса. Первый и второй элементы кортежа задают соответственно наименьший и наибольший индексы.
newGenArray :: (MArray a e m, Ix i) => (i, i) -> (i -> m e) -> m (a i e) Исходный код
Создаёт изменяемый массив с помощью функции-генератора. Вызывает функцию-генератор в порядке возрастания индексов.
Начиная с: array-0.5.6.0
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 () Исходный код
Записывает элемент в изменяемый массив
modifyArray :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m () Исходный код
Изменяет элемент в изменяемом массиве
Начиная с: array-0.5.6.0
modifyArray' :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m () Исходный код
Изменяет элемент в изменяемом массиве. Записываемый элемент вычисляется строго.
Начиная с: array-0.5.6.0
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) Исходный код
Создаёт новый массив на основе исходного, применяя функцию к каждому индексу.
foldlMArray' :: (MArray a e m, Ix i) => (b -> e -> b) -> b -> a i e -> m b Исходный код
Строгое левоассоциативное свёртывание с накапливаемым значением.
Начиная с: array-0.5.8.0
foldrMArray' :: (MArray a e m, Ix i) => (e -> b -> b) -> b -> a i e -> m b Исходный код
Строгое правоассоциативное свёртывание с накапливаемым значением.
Начиная с: array-0.5.8.0
foldlMArrayM' :: (MArray a e m, Ix i) => (b -> e -> m b) -> b -> a i e -> m b Исходный код
Строгое левоассоциативное монадическое свёртывание с накапливаемым значением.
Начиная с: array-0.5.8.0
foldrMArrayM' :: (MArray a e m, Ix i) => (e -> b -> m b) -> b -> a i e -> m b Исходный код
Строгое правоассоциативное монадическое свёртывание с накапливаемым значением.
Начиная с: array-0.5.8.0
mapMArrayM_ :: (MArray a e m, Ix i) => (e -> m b) -> a i e -> m () Исходный код
Преобразует элементы в монадические действия, выполняет их слева направо и отбрасывает результаты.
Начиная с: array-0.5.8.0
forMArrayM_ :: (MArray a e m, Ix i) => a i e -> (e -> m b) -> m () Исходный код
forMArrayM_ — это mapMArrayM_ с аргументами в обратном порядке.
Начиная с: array-0.5.8.0
data STUArray s i e Исходный код
Изменяемый массив с неупакованными элементами, которым можно манипулировать в монаде ST. Аргументы типа имеют следующее назначение:
-
s: аргумент-переменная состояния для типаST -
i: тип индекса массива (должен быть экземпляромIx) -
e: тип элементов массива. Поддерживаются только некоторые типы элементов.
STUArray обычно эффективнее (как по времени, так и по памяти), чем эквивалентный упакованный вариант (STArray) с тем же типом элементов. Однако STUArray строго вычисляет свои элементы — поэтому не используйте STUArray, если вам нужна нестрогость, обеспечиваемая STArray.
Конструкторы
| STUArray !i !i !Int (MutableByteArray# s) |
Экземпляры
unsafeNewArraySTUArray_ :: Ix i => (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e) Исходный код
bOOL_SCALE :: Int# -> Int# Исходный код
wORD_SCALE :: Int# -> Int# Исходный код
dOUBLE_SCALE :: Int# -> Int# Исходный код
fLOAT_SCALE :: Int# -> Int# Исходный код
safe_scale :: Int# -> Int# -> Int# Исходный код
bOOL_INDEX :: Int# -> Int# Исходный код
Индекс слова, в которое попадают заданные элементы массива Bool.
bOOL_BIT :: Int# -> Word# Исходный код
bOOL_NOT_BIT :: Int# -> Word# Исходный код
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) Исходный код
Преобразует изменяемый массив (любой экземпляр MArray) в неизменяемый массив (любой экземпляр IArray), создавая его полную копию.
freezeSTUArray :: 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) Источник
Преобразует изменяемый массив в неизменяемый. Реализация может просто привести массив от одного типа к другому без копирования или создать полную копию массива.
Обратите внимание: поскольку массив может быть не скопирован, любые последующие изменения изменяемой версии массива могут быть также видны в неизменяемой версии. Поэтому использовать эту функцию безопасно, если изменяемая версия больше не изменяется после замораживания.
Реализация без копирования поддерживается только для некоторых пар типов массивов; одно из условий состоит в том, что типы массивов должны иметь одинаковое представление. В GHC следующие пары типов массивов имеют реализацию unsafeFreeze без копирования с асимптотикой O(1). Поскольку оптимизированные версии включаются с помощью специализаций, для их получения необходимо скомпилировать код с оптимизацией (-O).
thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) Источник
Преобразует неизменяемый массив (любой экземпляр IArray) в изменяемый массив (любой экземпляр MArray), создавая его полную копию.
thawSTUArray :: 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) Источник
Преобразует неизменяемый массив в изменяемый. Реализация может просто привести массив от одного типа к другому без копирования или создать полную копию массива.
Обратите внимание: поскольку массив может быть не скопирован, любые последующие изменения изменяемой версии массива могут быть также видны в неизменяемой версии. Поэтому использовать эту функцию безопасно, только если в этом потоке к неизменяемому массиву больше никогда не будут обращаться и отсутствует вероятность обращения к нему из другого потока. Если в многопоточной среде вы используете последовательность unsafeThawwriteunsafeFreeze, необходимо обеспечить её атомарность по отношению к другим потокам, иначе может произойти сбой сборщика мусора (поскольку запись может выполняться в замороженный массив).
Реализация без копирования поддерживается только для некоторых пар типов массивов; одно из условий состоит в том, что типы массивов должны иметь одинаковое представление. В GHC следующие пары типов массивов имеют реализацию unsafeThaw без копирования с асимптотикой O(1). Поскольку оптимизированные версии включаются с помощью специализаций, для их получения необходимо скомпилировать код с оптимизацией (-O).
unsafeThawSTUArray :: UArray i e -> ST s (STUArray s i e) Источник
unsafeThawIOArray :: Array ix e -> IO (IOArray ix e) Источник
thawIOArray :: Array ix e -> IO (IOArray ix e) Источник
freezeIOArray :: IOArray ix e -> IO (Array ix e) Источник
unsafeFreezeIOArray :: IOArray ix e -> IO (Array ix e) Источник
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b) Источник
Преобразует STUArray с одним типом элементов в массив с другим типом элементов. Все элементы результирующего массива не определены (если только вы не знаете, что делаете...).
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/9.14.1/docs/libraries/array-0.5.8.0-93e8/Data-Array-Base.html
