Feldspar.Data.Array

Data structures for working with arrays

Documentation

data Nest a

Nested data structure (see explanation of nest)

Instances

Functor Nest

Defined in Feldspar.Data.Array

Methods

fmap :: (a -> b) -> Nest a -> Nest b

(<$) :: a -> Nest b -> Nest a

Foldable Nest

Defined in Feldspar.Data.Array

Methods

fold :: Monoid m => Nest m -> m

foldMap :: Monoid m => (a -> m) -> Nest a -> m

foldMap' :: Monoid m => (a -> m) -> Nest a -> m

foldr :: (a -> b -> b) -> b -> Nest a -> b

foldr' :: (a -> b -> b) -> b -> Nest a -> b

foldl :: (b -> a -> b) -> b -> Nest a -> b

foldl' :: (b -> a -> b) -> b -> Nest a -> b

foldr1 :: (a -> a -> a) -> Nest a -> a

foldl1 :: (a -> a -> a) -> Nest a -> a

toList :: Nest a -> [a]

null :: Nest a -> Bool

length :: Nest a -> Int

elem :: Eq a => a -> Nest a -> Bool

maximum :: Ord a => Nest a -> a

minimum :: Ord a => Nest a -> a

sum :: Num a => Nest a -> a

product :: Num a => Nest a -> a

Traversable Nest

Defined in Feldspar.Data.Array

Methods

traverse :: Applicative f => (a -> f b) -> Nest a -> f (Nest b)

sequenceA :: Applicative f => Nest (f a) -> f (Nest a)

mapM :: Monad m => (a -> m b) -> Nest a -> m (Nest b)

sequence :: Monad m => Nest (m a) -> m (Nest a)

MonadComp m => Manifestable2 m (Manifest2 a) a

manifest2 and manifestFresh2 are no-ops. manifestStore2 does a proper arrCopy.

Defined in Feldspar.Data.Vector

Methods

manifest2 :: Arr a -> Manifest2 a -> m (Manifest2 a)

manifestFresh2 :: Manifest2 a -> m (Manifest2 a)

manifestStore2 :: Arr a -> Manifest2 a -> m ()

(Syntax a, MonadComp m) => Pushy2 m (Manifest2 a) a

Defined in Feldspar.Data.Vector

Methods

toPush2 :: Manifest2 a -> Push2 m a

Slicable a => Slicable (Nest a)

Defined in Feldspar.Data.Array

Methods

slice :: Data Index -> Data Length -> Nest a -> Nest a

Finite (Nest a)

Defined in Feldspar.Data.Array

Methods

length :: Nest a -> Data Length

Slicable a => Indexed (Nest a)

Defined in Feldspar.Data.Array

Associated Types

type IndexedElem (Nest a)

Methods

(!) :: Nest a -> Data Index -> IndexedElem (Nest a)

MarshalFeld a => MarshalFeld (Nest a)

Note that HaskellRep (Nest a) = (Length, Length, HaskellRep a) rather than [HaskellRep a]. This means that e.g. Nest (Nest (Fin (IArr a))) is represented as (Length,Length,(Length,Length,(Length,[...]))) instead of the more convenient [[...]].

Defined in Feldspar.Data.Array

Associated Types

type HaskellRep (Nest a)

Methods

fwrite :: Handle -> Nest a -> Run ()

fread :: Handle -> Run (Nest a)

Finite2 (Nest a)

Defined in Feldspar.Data.Array

Methods

extent2 :: Nest a -> (Data Length, Data Length)

Syntax a => Storable (Manifest2 a)

Defined in Feldspar.Data.Storable

Associated Types

type StoreRep (Manifest2 a)

type StoreSize (Manifest2 a)

Methods

newStoreRep :: MonadComp m => proxy (Manifest2 a) -> StoreSize (Manifest2 a) -> m (StoreRep (Manifest2 a))

initStoreRep :: MonadComp m => Manifest2 a -> m (StoreRep (Manifest2 a))

readStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

writeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> Manifest2 a -> m ()

ViewManifest2 (Manifest2 a) a

Defined in Feldspar.Data.Vector

Methods

viewManifest2 :: Manifest2 a -> Maybe (Manifest2 a)

(Indexed vec, Slicable vec, IndexedElem vec ~ a, Syntax a) => Pully2 (Nest vec) a

Defined in Feldspar.Data.Vector

Methods

toPull2 :: Nest vec -> Pull2 a

type IndexedElem (Nest a)

Defined in Feldspar.Data.Array

type IndexedElem (Nest a) = a

type HaskellRep (Nest a)

Defined in Feldspar.Data.Array

type HaskellRep (Nest a) = (Length, Length, HaskellRep a)

type StoreRep (Manifest2 a)

Defined in Feldspar.Data.Storable

type StoreRep (Manifest2 a) = (DRef Length, DRef Length, Arr a)

type StoreSize (Manifest2 a)

Defined in Feldspar.Data.Storable

type StoreSize (Manifest2 a) = (Data Length, Data Length)

nest

Arguments

:: Finite a

=> Data Length

Number of segments

-> Data Length

Segment length

-> a

-> Nest a

Add a layer of nesting to a linear data structure by virtually chopping it up into segments. The nesting is virtual in the sense that unnest (nest h w a) is syntactically identical to a.

In an expression nest l w a, it must be the case that l*w == length a.

multiNest may be a more convenient alternative to nest, expecially for adding several levels of nesting.

nestEvery

Arguments

:: Finite a

=> Data Length

Segment length

-> a

-> Nest a

A version of nest that only takes the segment length as argument. The total number of segments is computed by division.

In an expression nestEvery n a, it must be the case that div (length a) n * n == length a.

This assumption permits removing the division in many cases when the nested structure is later flattened in some way.

unnest :: Slicable a => Nest a -> a

Remove a layer of nesting

data Dim d

Increase dimensionality

This type is used to represent the number of dimensions of a multi-dimensional structure. For example, Dim (Dim ()) means two dimensions (see the aliases Dim1, Dim2, etc.).

type Dim1 = Dim ()

One dimension

type Dim2 = Dim Dim1

Two dimensions

type Dim3 = Dim Dim2

Three dimensions

type Dim4 = Dim Dim3

Four dimensions

data InnerExtent d where

A description of the inner extent of a rectangular multi-dimensional structure. "Inner extent" means the extent of all but the outermost dimension.

For example, this value

Outer :> 10 :> 20 :: InnerExtent (Dim (Dim (Dim ())))

describes a three-dimensional structure where each inner structure has 10 rows and 20 columns.

Constructors

NoExt :: InnerExtent ()

Outer :: InnerExtent (Dim ())

(:>) :: InnerExtent (Dim d) -> Data Length -> InnerExtent (Dim (Dim d)) infixl 5

listExtent :: InnerExtent d -> [Data Length]

Return the inner extent as a list of lengths

type family MultiNest d a where ...

Add as much nesting to a one-dimensional structure as needed to reach the given dimensionality

Equations

MultiNest (Dim ()) a = a

MultiNest (Dim (Dim d)) a = Nest (MultiNest (Dim d) a)

multiNest :: forall a d. Finite a => InnerExtent (Dim d) -> a -> MultiNest (Dim d) a

Turn a one-dimensional structure into a multi-dimensional one by adding nesting as described by the given InnerExtent

data InnerExtent' d where

A version of InnerExtent for internal use

Constructors

ZE :: InnerExtent' ()

OE :: InnerExtent' (Dim ())

SE :: Data Length -> InnerExtent' d -> InnerExtent' (Dim d)

listExtent' :: InnerExtent' d -> [Data Length]

tailExtent' :: InnerExtent' (Dim d) -> InnerExtent' d

convInnerExtent :: InnerExtent d -> InnerExtent' d

2-dimensional arrays

class Finite2 a where

Methods

extent2

Arguments

:: a

-> (Data Length, Data Length)

(rows,columns)

Get the extent of a 2-dimensional vector

It must hold that:

numRows == length

Instances

Finite2 (Nest a)

Defined in Feldspar.Data.Array

Methods

extent2 :: Nest a -> (Data Length, Data Length)

Finite2 (Pull2 a)

Defined in Feldspar.Data.Vector

Methods

extent2 :: Pull2 a -> (Data Length, Data Length)

Finite2 (Pull a)

Treated as a row vector

Defined in Feldspar.Data.Vector

Methods

extent2 :: Pull a -> (Data Length, Data Length)

Finite2 (Manifest a)

Treated as a row vector

Defined in Feldspar.Data.Vector

Methods

extent2 :: Manifest a -> (Data Length, Data Length)

Finite2 (Push2 m a)

Defined in Feldspar.Data.Vector

Methods

extent2 :: Push2 m a -> (Data Length, Data Length)

Finite2 (Push m a)

Treated as a row vector

Defined in Feldspar.Data.Vector

Methods

extent2 :: Push m a -> (Data Length, Data Length)

numRows :: Finite2 a => a -> Data Length

Get the number of rows of a two-dimensional structure

numRows == length

numCols :: Finite2 a => a -> Data Length

Get the number of columns of a two-dimensional structure