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

Data.Vec.Base

Synopsis

# Documentation

data a :. b 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

Instances

class ShowVec v whereSource

Methods

showVec :: v -> StringSource

Instances

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

# Vector Types

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

type Vec3 a = a :. Vec2 aSource

type Vec4 a = a :. Vec3 aSource

type Vec5 a = a :. Vec4 aSource

type Vec6 a = a :. Vec5 aSource

type Vec7 a = a :. Vec6 aSource

type Vec8 a = a :. Vec7 aSource

type Vec9 a = a :. Vec8 aSource

type Vec10 a = a :. Vec9 aSource

type Vec11 a = a :. Vec10 aSource

type Vec12 a = a :. Vec11 aSource

type Vec13 a = a :. Vec12 aSource

type Vec14 a = a :. Vec13 aSource

type Vec15 a = a :. Vec14 aSource

type Vec16 a = a :. Vec15 aSource

type Vec17 a = a :. Vec16 aSource

type Vec18 a = a :. Vec17 aSource

type Vec19 a = a :. Vec18 aSource

class Vec n a v | n a -> v, v -> n a whereSource

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 -> vSource

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 -> vSource

Make a uniform vector. The length is inferred.

class VecList a v | v -> a whereSource

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

Methods

fromList :: [a] -> vSource

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 -> aSource

Get a vector element, which one determined at runtime.

setElem :: Int -> a -> v -> vSource

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 whereSource

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 -> aSource

set :: n -> a -> v -> vSource

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 whereSource

The first element.

Methods

Instances

class Tail v v_ | v -> v_ whereSource

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 whereSource

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 -> vSource

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 whereSource

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 -> wSource

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 whereSource

Fold a function over a vector.

Methods

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

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

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

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' whereSource

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 whereSource

Append two vectors

Methods

append :: v1 -> v2 -> v3Source

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' whereSource

`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' whereSource

`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 whereSource

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

Methods

last :: v -> aSource

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 whereSource

`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 whereSource

The length of a vector

Methods

length :: v -> IntSource

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 -> aSource

sum of vector elements

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

product of vector elements

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

maximum vector element

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

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]] -> mSource

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] -> mSource

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

class VecArrayRW v whereSource

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))