Vec-1.0.5: Fixed-length lists and low-dimensional linear algebra.

Data.Vec.Base

Synopsis

# Documentation

data a :. b infixr 9 Source

The vector constructor. `(:.)` for vectors is like `(:)` for lists, and `()` takes the place of `[]`. (The list of instances here is not meant to be readable.)

Constructors

 !a :. !b infixr 9

Instances

class ShowVec v where Source

Methods

showVec :: v -> String Source

Instances

 ShowVec () (Show a, ShowVec v) => ShowVec ((:.) a v)

# Vector Types

type Vec2 a = a :. (a :. ()) Source

type Vec3 a = a :. Vec2 a Source

type Vec4 a = a :. Vec3 a Source

type Vec5 a = a :. Vec4 a Source

type Vec6 a = a :. Vec5 a Source

type Vec7 a = a :. Vec6 a Source

type Vec8 a = a :. Vec7 a Source

type Vec9 a = a :. Vec8 a Source

type Vec10 a = a :. Vec9 a Source

type Vec11 a = a :. Vec10 a Source

type Vec12 a = a :. Vec11 a Source

type Vec13 a = a :. Vec12 a Source

type Vec14 a = a :. Vec13 a Source

type Vec15 a = a :. Vec14 a Source

type Vec16 a = a :. Vec15 a Source

type Vec17 a = a :. Vec16 a Source

type Vec18 a = a :. Vec17 a Source

type Vec19 a = a :. Vec18 a Source

class Vec n a v | n a -> v, v -> n a where Source

The type constraint `Vec n a v` infers the vector type `v` from the length `n`, a type-level natural, and underlying component type `a`. So `x :: Vec N4 a v => v` declares `x` to be a 4-vector of `a`s.

Methods

mkVec :: n -> a -> v Source

Make a uniform vector of a given length. `n` is a type-level natural. Use `vec` when the length can be inferred.

Instances

 Vec N1 a ((:.) a ()) Vec (Succ n) a ((:.) a' v) => Vec (Succ (Succ n)) a ((:.) a ((:.) a' v))

vec :: Vec n a v => a -> v Source

Make a uniform vector. The length is inferred.

class VecList a v | v -> a where Source

Build a vector from a list, or access vector elements using run-time indicies, numbered from 0.

Methods

fromList :: [a] -> v Source

Turn a list into a vector of inferred length. The list must be at least as long as the vector, but may be longer. Make a mental note of the distinction between this and `matFromList`, as you might accidentally use this when you mean that. Because number literals can be converted to vectors, and matrices are vectors of vectors, the following works

```fromList [1,2,3,4] :: Mat22 Int
> ((1):.(1):.()):.((2):.(2):.()):.()```

even though we meant to do this

```matFromList [1,2,3,4] :: Mat22 Int
> ((1):.(2):.()):.((3):.(4):.()):.()```

getElem :: Int -> v -> a Source

Get a vector element, which one determined at runtime.

setElem :: Int -> a -> v -> v Source

Set a vector element, which one determined at runtime

Instances

 (VecList a v, PackedVec v) => VecList a (Packed v) VecList a ((:.) a' v) => VecList a ((:.) a ((:.) a' v)) VecList a ((:.) a ())

class Access n a v | v -> a where Source

get or set a vector element, known at compile time. Use the Nat types to access vector components. For instance, `get n0` gets the x component, `set n2 44` sets the z component to 44.

Methods

get :: n -> v -> a Source

set :: n -> a -> v -> v Source

Instances

 (Access n a v, PackedVec v) => Access n a (Packed v) Access N0 a ((:.) a v) Access n a v => Access (Succ n) a ((:.) a v)

# List-like functions

class Head v a | v -> a where Source

The first element.

Methods

head :: v -> a Source

Instances

class Tail v v_ | v -> v_ where Source

All but the first element.

Methods

tail :: v -> v_ Source

Instances

 (Tail v t, PackedVec v, PackedVec t) => Tail (Packed v) (Packed t) Tail ((:.) a as) as

class Map a b u v | u -> a, v -> b, b u -> v, a v -> u where Source

Apply a function over each element in a vector. Constraint `Map a b u v` states that `u` is a vector of `a`s, `v` is a vector of `b`s with the same length as `u`, and the function is of type `a -> b`.

Methods

map :: (a -> b) -> u -> v Source

Instances

 (Map a b u v, PackedVec u, PackedVec v) => Map a b (Packed u) (Packed v) Map a b ((:.) a' u) ((:.) b' v) => Map a b ((:.) a ((:.) a' u)) ((:.) b ((:.) b' v)) Map a b ((:.) a ()) ((:.) b ())

class ZipWith a b c u v w | u -> a, v -> b, w -> c, u v c -> w where Source

Combine two vectors using a binary function. The length of the result is the min of the lengths of the arguments. The constraint ```ZipWith a b c u v w``` states that `u` is a vector of `a`s, `v` is a vector of `b`s, `w` is a vector of `c`s, and the binary function is of type `a -> b -> c`.

Methods

zipWith :: (a -> b -> c) -> u -> v -> w Source

Instances

 (ZipWith a b c u v w, PackedVec u, PackedVec v, PackedVec w) => ZipWith a b c (Packed u) (Packed v) (Packed w) ZipWith a b c ((:.) a' u) ((:.) b' v) ((:.) c' w) => ZipWith a b c ((:.) a ((:.) a' u)) ((:.) b ((:.) b' v)) ((:.) c ((:.) c' w)) ZipWith a b c ((:.) a ((:.) a as)) ((:.) b ()) ((:.) c ()) ZipWith a b c ((:.) a ()) ((:.) b ((:.) b bs)) ((:.) c ()) ZipWith a b c ((:.) a ()) ((:.) b ()) ((:.) c ())

class Fold v a | v -> a where Source

Fold a function over a vector.

Methods

fold :: (a -> a -> a) -> v -> a Source

foldl :: (b -> a -> b) -> b -> v -> b Source

foldr :: (a -> b -> b) -> b -> v -> b Source

Instances

 (Fold v a, PackedVec v) => Fold (Packed v) a Fold ((:.) a' u) a => Fold ((:.) a ((:.) a' u)) a Fold ((:.) a ()) a

reverse :: Reverse' () v v' => v -> v' Source

Reverse a vector

class Reverse' p v v' | p v -> v' where Source

Reverse helper function : accumulates the reversed list in its first argument

Methods

reverse' :: p -> v -> v' Source

Instances

 Reverse' p () p (Reverse' () v v', PackedVec v, PackedVec v') => Reverse' () (Packed v) (Packed v') Reverse' ((:.) a p) v v' => Reverse' p ((:.) a v) v'

class Append v1 v2 v3 | v1 v2 -> v3, v1 v3 -> v2 where Source

Append two vectors

Methods

append :: v1 -> v2 -> v3 Source

Instances

 Append () v v Append ((:.) a' v1) v2 v3 => Append ((:.) a ((:.) a' v1)) v2 ((:.) a v3) Append ((:.) a ()) v ((:.) a v)

class Take n v v' | n v -> v' where Source

`take n v` constructs a vector from the first `n` elements of `v`. `n` is a type-level natural. For example `take n3 v` makes a 3-vector of the first three elements of `v`.

Methods

take :: n -> v -> v' Source

Instances

 Take N0 v () (Take (Succ n) v v', PackedVec v, PackedVec v') => Take (Succ n) (Packed v) (Packed v') Take n v v' => Take (Succ n) ((:.) a v) ((:.) a v')

class Drop n v v' | n v -> v' where Source

`drop n v` strips the first `n` elements from `v`. `n` is a type-level natural. For example `drop n2 v` drops the first two elements.

Methods

drop :: n -> v -> v' Source

Instances

 Drop N0 v v (Drop n v v', PackedVec v, PackedVec v') => Drop n (Packed v) (Packed v') Drop n ((:.) a v) v' => Drop (Succ n) ((:.) a ((:.) a v)) v'

class Last v a | v -> a where Source

Get the last element, usually significant for some reason (quaternions, homogenous coordinates, whatever)

Methods

last :: v -> a Source

Instances

 (Last v l, PackedVec v) => Last (Packed v) l Last ((:.) a' v) a => Last ((:.) a ((:.) a' v)) a Last ((:.) a ()) a

class Snoc v a v' | v a -> v', v' -> v a where Source

`snoc v a` appends the element a to the end of v.

Methods

snoc :: v -> a -> v' Source

Instances

 Snoc () a ((:.) a ()) (Snoc v a v', PackedVec v, PackedVec v') => Snoc (Packed v) a (Packed v') Snoc v a ((:.) a v) => Snoc ((:.) a v) a ((:.) a ((:.) a v))

class Length v n | v -> n where Source

The length of a vector

Methods

length :: v -> Int Source

Instances

 Length () N0 (Length v n, PackedVec v) => Length (Packed v) n Length v n => Length ((:.) a v) (Succ n)

sum :: (Fold v a, Num a) => v -> a Source

sum of vector elements

product :: (Fold v a, Num a) => v -> a Source

product of vector elements

maximum :: (Fold v a, Ord a) => v -> a Source

maximum vector element

minimum :: (Fold v a, Ord a) => v -> a Source

minimum vector element

toList :: Fold v a => v -> [a] Source

# Matrix Types

type Mat22 a = Vec2 (Vec2 a) Source

type Mat23 a = Vec2 (Vec3 a) Source

type Mat24 a = Vec2 (Vec4 a) Source

type Mat32 a = Vec3 (Vec2 a) Source

type Mat33 a = Vec3 (Vec3 a) Source

type Mat34 a = Vec3 (Vec4 a) Source

type Mat35 a = Vec3 (Vec5 a) Source

type Mat36 a = Vec3 (Vec6 a) Source

type Mat42 a = Vec4 (Vec2 a) Source

type Mat43 a = Vec4 (Vec3 a) Source

type Mat44 a = Vec4 (Vec4 a) Source

type Mat45 a = Vec4 (Vec5 a) Source

type Mat46 a = Vec4 (Vec6 a) Source

type Mat47 a = Vec4 (Vec7 a) Source

type Mat48 a = Vec4 (Vec8 a) Source

matToLists :: (Fold v a, Fold m v) => m -> [[a]] Source

convert a matrix to a list-of-lists

matToList :: (Fold v a, Fold m v) => m -> [a] Source

convert a matrix to a list in row-major order

matFromLists :: (Vec j a v, Vec i v m, VecList a v, VecList v m) => [[a]] -> m Source

convert a list-of-lists into a matrix

matFromList :: forall i j v m a. (Vec i v m, Vec j a v, Nat i, VecList a v, VecList v m) => [a] -> m Source

convert a list into a matrix. (row-major order)

class VecArrayRW v where Source

Instances

 VecArrayRW ((:.) Double ()) VecArrayRW ((:.) Double v) => VecArrayRW ((:.) Double ((:.) Double v)) VecArrayRW ((:.) Float ()) VecArrayRW ((:.) Float v) => VecArrayRW ((:.) Float ((:.) Float v)) VecArrayRW ((:.) Int ()) VecArrayRW ((:.) Int v) => VecArrayRW ((:.) Int ((:.) Int v)) VecArrayRW ((:.) Word8 ()) VecArrayRW ((:.) Word8 v) => VecArrayRW ((:.) Word8 ((:.) Word8 v))