array is:package

Mutable and immutable arrays In addition to providing the Data.Array module as specified in the Haskell 2010 Language Report, this package also defines the classes IArray of immutable arrays and MArray of arrays mutable within appropriate monads, as well as some instances of these classes.

Not on Stackage, so not searched. Builders for arrays

Lists of chunks Lists of chunks. This is similar to the Cons List provided by Data.List, but it is more useful as a target for a builder since the chunks are cache coherent.

Not on Stackage, so not searched. A simple interpreter for arrayForth, the language used on GreenArrays chips.

Not on Stackage, so not searched. Extra foreign primops for primitive arrays

Not on Stackage, so not searched. Haskell bindings to the ArrayFire general-purpose GPU library

Not on Stackage, so not searched. Memory-efficient ArrayList implementation

Not on Stackage, so not searched. IsList instances of Array for OverloadedLists extension

Documentation not found, so not searched. Memoization combinators using arrays for finite sub-domains of functions

Not on Stackage, so not searched. Primitive functions for updating many elements in mutable arrays at once

Not on Stackage, so not searched. Unboxed references, dynamic arrays and more

Arrays where the index type is a function of the shape type Arrays from the basic array package are already very powerful compared with arrays in other languages. They may have any number of dimensions, are type safe and defined in a uniform way using the Ix class with free choice of the lower bounds (0, 1, or whatever you like). This package goes one step further: The shape and the index type are different, but the index type is a type function of the shape type. This offers much more flexibility and type safety. Some Shape example types are:

• Range: Allow dynamic choice of lower and upper array bounds such as in the Arrays from the array package. You can combine it with other shapes in other dimensions. It allows you to describe the bounds of each dimension individually.
• Shifted: Describe array bounds by start index and length. It is sometimes more natural to use these parameters. E.g. a non-negative index type like Word cannot represent -1 and thus cannot encode an empty range starting with index 0.
• ZeroBased, OneBased: Arrays with fixed lower bound, either 0 or 1, respectively.
• Cyclic: Indices with wrap-around semantics.
• Zero, (): Arrays with fixed size 0 or 1, respectively.
• Enumeration: Arrays with indices like LT, EQ, GT and a shape of fixed size.
• NestedTuple: Arrays with shapes that are compatible to nested tuples like (a,(a,a)) and indices like fst and fst.snd.
• (::+): The Append type constructor allows to respresent block arrays, e.g. block matrices. It also allows to represent non-empty arrays via ()::+sh.
• Set: Use an arbitrary ordered set as index set.
• Map: Concatenate a set of shapes. In a higher dimensional array it can be used for block matrices with a dynamic number of blocks but block sizes of the same shape type.
• Triangular: A 2D array with the shape of a lower or upper triangular matrix.
• Simplex: Simplices of any dimension, where the dimension is encoded in the type. An index is a tuple of monotonic ordered sub-indices.
• Square: A 2D array where both dimensions always have equal size.
• Cube: A 3D array where all three dimensions always have equal size.
• Tagged: Statically distinguish shapes and indices that are isomorphic.

With our Array type you can perform

• Fast Linear Algebra using the packages comfort-blas and lapack. The lapack package defines even more fancy shapes like tall rectangular matrices, triangular matrices and banded matrices.
• Fast Fourier Transforms using the package comfort-fftw
• Fast Linear Programming using the packages comfort-glpk, coinor-clp, highs-lp
• Efficient Array Processing via LLVM Just-In-Time code generation using the package knead.

See also comfort-graph for a Graph data structure, with non-Int node identifiers and flexible edge types.

Not on Stackage, so not searched. Efficient multidimensional arrays

A library that can be used for multiple Ord a => a -> b transformations. A library that can be used as a case ... of construction replacement for various cases. Since the 0.2.0.0 version also uses the cuckoo hashtables in the respective module. Since the 0.3.0.0 version the hashing functionality moved to the separate package mmsyn2-hashable.

A C-compatible array library. A C-compatible array library. Provides both an immutable and mutable (in the IO monad) interface. Includes utilities for multi-dimensional arrays, slicing and norms. Memory is 16-byte aligned by default to enable use of vector instructions.

Compatibility layer for Data.Array.Byte Compatibility layer for Data.Array.Byte, providing boxed wrappers for ByteArray# and MutableByteArray# and relevant instances for GHC < 9.4. Include it into your Cabal file:

build-depends: base
if impl(ghc < 9.4)
build-depends: data-array-byte

and then import Data.Array.Byte unconditionally.

Not on Stackage, so not searched. A library to work with the basic Ukrainian phonetics and syllable segmentation.

Not on Stackage, so not searched. Permutations and universal set related functions for the phonetic-languages series

Not on Stackage, so not searched. Pretty-printing for primitive arrays

Additional shape types for the comfort-array package Some extra array shape types additional to the ones in the comfort-array package. These require some more package dependencies and use type-encoded natural numbers.

• Static.ZeroBased: Like Shape.ZeroBased but with type-encoded number as size.
• Simplex: Simplices of any dimension, where the dimension is encoded in the type. Only a private module for demonstration. Production-ready implementation in comfort-array.

Multi-dimensional arrays. This package provides an interface into the numhask API, and both type- and value-level shape manipulation routines.

Usage

>>> {-# LANGUAGE RebindableSyntax #-}

>>> import NumHask.Prelude

>>> import NumHask.Array

In situations where shape is only known at runtime, a clear module configuration is:

>>> import NumHask.Array.Shape

>>> import qualified NumHask.Array.Fixed as F

>>> import qualified NumHask.Array.Dynamic as D

Not on Stackage, so not searched. Constraints to filter the needed permutations

Not on Stackage, so not searched. Common functionality for 'with-tuples' and old version of properties.

Not on Stackage, so not searched. Prepares Ukrainian text to be used as a PhLADiPreLiO text

Helper modules for CArray wrappers to BLAS and LAPACK Netlib is a collection of packages for efficient numeric linear algebra. Most prominent parts of Netlib are BLAS and LAPACK. These packages contain functions for matrix computations, solution of simultaneous linear equations and eigenvalue problems. This package provides definitions shared by the packages blas-carray and lapack-carray.