feldspar-language-0.6.0.2: A functional embedded language for DSP and parallelism

Safe HaskellNone

Feldspar.Vector.Internal

Contents

Synopsis

Types

data Vector a

Symbolic vector

Instances

Len Vector 
Ixmap Vector 
Pushy Vector 
(Syntax a, Show (Internal a)) => Show (Vector a) 
Annotatable a => Annotatable (Vector a) 
(Arbitrary (Internal a), Syntax a) => Arbitrary (Vector a) 
Syntax a => Syntactic (Vector a) 
Syntax a => Sized (Vector a) 
Syntax a => Indexed (Vector a) 
Syntax a => Syntax (Vector a) 
(ElemWise a, Syntax (Vector a)) => ElemWise (Vector a) 
CollMap (Vector a) (Vector b) 
Type a => Wrap (Vector (Data a)) (Data [a]) 
Type a => Wrap (Matrix a) (Data [[a]]) 
Numeric a => Mul (Data a) (Matrix a) 
Numeric a => Mul (Data a) (Vector1 a) 
Numeric a => Mul (Vector1 a) (Matrix a) 
Numeric a => Mul (Vector1 a) (Vector1 a) 
Numeric a => Mul (Vector1 a) (Data a) 
Numeric a => Mul (Matrix a) (Matrix a) 
Numeric a => Mul (Matrix a) (Vector1 a) 
Numeric a => Mul (Matrix a) (Data a) 
(Wrap t u, Type a, Nat s) => Wrap (Vector1 a -> t) (Data' s [a] -> u) 
(Wrap t u, Type a, Nat row, Nat col) => Wrap (Matrix a -> t) (Data' (row, col) [[a]] -> u) 

type Vector1 a = Vector (Data a)

Non-nested vector

type Vector2 a = Vector (Vector (Data a))

Two-level nested vector

Construction/conversion

indexed :: Data Length -> (Data Index -> a) -> Vector a

segments :: Vector a -> [Vector a]

Breaks up a segmented vector into a list of single-segment vectors.

mergeSegments :: Syntax a => Vector a -> Vector a

Converts a segmented vector to a vector with a single segment.

freezeVector :: Type a => Vector (Data a) -> Data [a]

Converts a non-nested vector to a core vector.

thawVector :: Type a => Data [a] -> Vector (Data a)

Converts a non-nested core array to a vector.

thawVector' :: Type a => Length -> Data [a] -> Vector (Data a)

Operations

newLen :: Syntax a => Data Length -> Vector a -> Vector a

Change the length of the vector to the supplied value. If the supplied length is greater than the old length, the new elements will have undefined value. The resulting vector has only one segment.

(++) :: Vector a -> Vector a -> Vector a

splitAt :: Data Index -> Vector a -> (Vector a, Vector a)

head :: Syntax a => Vector a -> a

last :: Syntax a => Vector a -> a

tail :: Vector a -> Vector a

init :: Vector a -> Vector a

permute' :: (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a

Permute a single-segment vector

permute :: Syntax a => (Data Length -> Data Index -> Data Index) -> Vector a -> Vector a

Permute a vector

reverse :: Syntax a => Vector a -> Vector a

enumFromTo :: forall a. Integral a => Data a -> Data a -> Vector (Data a)

enumFromTo m n: Enumerate the integers from m to n

enumFrom :: Integral a => Data a -> Vector (Data a)

enumFrom m: Enumerate the indexes from m to maxBound

(...) :: Integral a => Data a -> Data a -> Vector (Data a)

map :: (a -> b) -> Vector a -> Vector b

map f v is the Vector obtained by applying f to each element of f.

zip :: (Syntax a, Syntax b) => Vector a -> Vector b -> Vector (a, b)

Zipping two Vectors

zip3 :: (Syntax a, Syntax b, Syntax c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)

Zipping three Vectors

zip4 :: (Syntax a, Syntax b, Syntax c, Syntax d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)

Zipping four Vectors

zip5 :: (Syntax a, Syntax b, Syntax c, Syntax d, Syntax e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)

Zipping five Vectors

unzip :: Vector (a, b) -> (Vector a, Vector b)

Unzip to two Vectors

unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)

Unzip to three Vectors

unzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)

Unzip to four Vectors

unzip5 :: Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)

Unzip to five Vectors

zipWith :: (Syntax a, Syntax b) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

Generalization of zip using the supplied function instead of tupling to combine the elements

zipWith3 :: (Syntax a, Syntax b, Syntax c) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d

Generalization of zip3 using the supplied function instead of tupling to combine the elements

zipWith4 :: (Syntax a, Syntax b, Syntax c, Syntax d) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e

Generalization of zip4 using the supplied function instead of tupling to combine the elements

zipWith5 :: (Syntax a, Syntax b, Syntax c, Syntax d, Syntax e) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f

Generalization of zip5 using the supplied function instead of tupling to combine the elements

fold :: Syntax a => (a -> b -> a) -> a -> Vector b -> a

Corresponds to the standard foldl.

fold1 :: Syntax a => (a -> a -> a) -> Vector a -> a

Corresponds to the standard foldl1.

sum :: (Syntax a, Num a) => Vector a -> a

maximum :: Ord a => Vector (Data a) -> Data a

minimum :: Ord a => Vector (Data a) -> Data a

scalarProd :: (Syntax a, Num a) => Vector a -> Vector a -> a

Scalar product of two vectors

tVec :: Patch a a -> Patch (Vector a) (Vector a)

tVec1 :: Patch a a -> Patch (Vector (Data a)) (Vector (Data a))

tVec2 :: Patch a a -> Patch (Vector (Vector (Data a))) (Vector (Vector (Data a)))