dense: Mutable and immutable dense multidimensional arrays

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Multidimentional array library build on top of the vector package, using indices from the linear package. Native support for mutable arrays, stencils and parallel computation.


[Skip to Readme]

Properties

Versions 0.1.0.0, 0.1.0.1, 0.1.0.1
Change log None available
Dependencies base (>=4.6 && <5), binary, bytes, cereal, comonad, deepseq, ghc-prim, hashable, lens, linear (>=1.20 && <1.22), primitive, semigroupoids, template-haskell, transformers, transformers-compat, vector (>=0.12 && <0.13) [details]
License BSD-3-Clause
Copyright (c) Christopher Chalmers 2016
Author cchalmers
Maintainer c.chalmers@me.com
Category Data
Source repo head: git clone https://github.com/cchalmers/dense
Uploaded by cchalmers at 2020-11-20T22:15:36Z

Modules

[Index] [Quick Jump]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


Readme for dense-0.1.0.1

[back to package description]

dense

Build Status Haddock Hackage

dense is a multidimensional array library build on top of the vector package, using indices from the linear package. Native support for mutable arrays, stencils and parallel computation.

Array type

Arrays are just vectors (from vector) with a shape:

data Array v f a = Array !(f Layout) !(v a)

where Layout f = f Int is the shape of the array, given by a vector from linear (V1, V2, V3 or V4). These vectors are also used to indexing:

> a ! V3 1 2 3

Delayed arrays

A delayed array, defined by

data Delayed f a = Delayed !(Layout f) (Int -> a)

can be constructing from a normal array via delay. It can be useful for mapping a function over an array and computing the result in parallel via manifest:

> manifest . fmap (+100) . delay

or equivalently using the delayed isomorphism:

> delayed +~ 100

Delayed is an instance of many classes, including Additive from linear:

> manifest $ delay a ^+^ 3 *^ delay b

Mutable

dense has similar mutable capabilities to vector, supporting mutable operations over a PrimMonad in Data.Dense.Mutable.

Stencils

dense has good stencil support, allowing construction of 1D, 2D or 3D stencils using template haskell and quasiquoters.

myStencil = [stencil|
  2/5 8/5 2/5
  8/5  2  8/5
  2/5 8/5 2/5
|]

Stencils made with template haskell are unrolled at compile time.

Comparison to other array libraries

array supports multidimensional and mutable arrays but dense provides many more high level functions as well as stencils and parallel computation.

repa and yarr dense has a lot of the same features as repa and yarr. Performance should be similar (more benchmarks needed) but dense also has support for mutable arrays and multidimensional stencils.

Package structure

Like vector, there is a Data.Shaped.Generic module for working over any generic vector as well as Data.Shaped.Unboxed and Data.Shaped.Storable modules. Unlike vector, boxed vectors are in Data.Shaped.Boxed.

The Data.Shaped module includes a subset of Data.Shaped.Generic as well as some extra reexports and is intended to be imported unqualified.