Data.Vec.Base

Documentation

data a :. b

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

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

Snoc () a (:. a ())

Access N0 a (:. a v)

Vec N1 a (:. a ())

(Access n a r, Append p (:. a ()) p', GetDiagonal' (Succ n) p' (:. r m) v) => GetDiagonal' n p (:. r (:. r m)) v

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

Map a b (:. a ()) (:. b ())

(Append p (:. a v) x, Append p (:. a ()) y, ReplConsec' a y v z) => ReplConsec' a p (:. a v) (:. x z)

(Access n a r, Append p (:. a ()) (:. a p)) => GetDiagonal' n p (:. r ()) (:. a p)

(VecArrayRW (:. a v), PackedVec (:. a v)) => IArray UArray (Packed (:. a v))

VecArrayRW (:. a v) => IArray UArray (:. a v)

VecList a (:. a' v) => VecList a (:. a (:. a' v))

VecList a (:. a ())

(Fractional a, Map (:. a r) r (:. (:. a r) rs) rs_, Map r (:. a r) rs_ (:. (:. a r) rs), Pivot a (:. (:. a r) (:. (:. a r) rs)), GaussElim a rs_) => GaussElim a (:. (:. a r) (:. (:. a r) rs))

(Num a, Pivot a (:. r ())) => GaussElim a (:. r ())

(Fractional a, NearZero a, Pivot1 a rs, Tail (:. a r) r, Map (:. a r) r (:. (:. a r) rs) (:. r rs'), Map r (:. a r) (:. r rs') (:. (:. a r) rs), Pivot1 a (:. (:. a r) rs), Pivot a (:. r rs')) => Pivot a (:. (:. a r) rs)

Pivot a (:. () v)

(Fractional a, NearZero a, Map a a (:. a r) (:. a r), ZipWith a a a (:. a r) (:. a r) (:. a r), Map (:. a r) (:. a r) (:. (:. a r) rs) (:. (:. a r) rs), Pivot1 a (:. (:. a r) rs)) => Pivot1 a (:. (:. a r) (:. (:. a r) rs))

(Fractional a, NearZero a, Map a a (:. a r) (:. a r)) => Pivot1 a (:. (:. a (:. a r)) ())

(Show a, Fractional a, NearZero a) => Pivot1 a (:. (:. a ()) ())

Reverse' (:. a p) v v' => Reverse' p (:. a v) v'

(Append p (:. a v) x, Append p (:. a ()) y, DropConsec' y (:. a v) z) => DropConsec' p (:. a (:. a v)) (:. x z)

DropConsec' p (:. a ()) (:. p ())

(SetDiagonal' (Succ n) v m, Access n a r) => SetDiagonal' n (:. a v) (:. r m)

PackedVec (Vec4 Double)

PackedVec (Vec4 Float)

PackedVec (Vec4 Int)

PackedVec (Vec3 Double)

PackedVec (Vec3 Float)

PackedVec (Vec3 Int)

PackedVec (Vec2 Double)

PackedVec (Vec2 Float)

PackedVec (Vec2 Int)

Access n a v => Access (Succ n) a (:. a v)

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

(VecArrayRW (:. a v), PackedVec (:. a v)) => MArray (STUArray s) (Packed (:. a v)) (ST s)

Drop n (:. a v) v' => Drop (Succ n) (:. a (:. a v)) v'

VecArrayRW (:. a v) => MArray (STUArray s) (:. a v) (ST s)

Take n v v' => Take (Succ n) (:. a v) (:. a v')

(Eq a, Eq b) => Eq (:. a b)

(Eq u, ShowVec u, Fractional a, Ord (:. a u), ZipWith a a a (:. a u) (:. a u) (:. a u), Map a a (:. a u) (:. a u), Vec (Succ l) a (:. a u), Show (:. a u)) => Fractional (:. a u)

(Eq u, ShowVec u, Num a, Map a a (:. a u) (:. a u), ZipWith a a a (:. a u) (:. a u) (:. a u), Vec (Succ l) a (:. a u)) => Num (:. a u)

(Ord a, Ord b) => Ord (:. a b)

(Read a, Read b) => Read (:. a b)

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

(Vec (Succ (Succ n)) a (:. a (:. a v)), Storable a, Storable (:. a v)) => Storable (:. a (:. a v))

Storable a => Storable (:. a ())

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

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

(Map (:. a r) r (:. (:. a r) rs) rs_, Map r (:. a r) rs_ (:. (:. a r) rs), Fold aas (a, :. a r), ZipWith a a a (:. a r) (:. a r) (:. a r), Map a a (:. a r) (:. a r), ZipWith a (:. a r) (a, :. a r) r (:. (:. a r) rs) aas, Num a, BackSubstitute' rs_) => BackSubstitute' (:. (:. a r) (:. (:. a r) rs))

BackSubstitute' (:. (:. a r) ())

(Map (:. a r) r (:. (:. a r) rs) rs_, Map r (:. a r) rs_ (:. (:. a r) rs), Fold aas (a, :. a r), ZipWith a a a (:. a r) (:. a r) (:. a r), Map a a (:. a r) (:. a r), ZipWith a (:. a r) (a, :. a r) r (:. (:. a r) rs) aas, Num a, NearZero a, BackSubstitute rs_) => BackSubstitute (:. (:. a r) (:. (:. a r) rs))

NearZero a => BackSubstitute (:. (:. a r) ())

(Num a, NegateOdds v) => NegateEvens (:. a v)

(Num a, NegateEvens v) => NegateOdds (:. a v)

Last (:. a' v) a => Last (:. a (:. a' v)) a

Last (:. a ()) a

Fold (:. a' u) a => Fold (:. a (:. a' u)) a

Fold (:. a ()) a

Tail (:. a as) as

Head (:. a as) a

(~ * (:. a (:. a v)) r, ~ * (:. (:. a (:. a v)) (:. (:. a (:. a v)) vs)) m, ~ * (:. (:. a v) (:. (:. a v) vs_)) m_, ~ * (:. (:. (:. a v) vs_) (:. x y)) mm, Map (:. a (:. a v)) (:. a v) m m_, DropConsec m_ mm, Det' (:. (:. a v) vs_) a, Map (:. (:. a v) vs_) a mm r, Map r a m r, NegateOdds r, Fold r a, Num r, Num a) => Det' (:. (:. a (:. a v)) (:. (:. a (:. a v)) vs)) a

Det' (:. (:. a ()) ()) a

Transpose' vs vs' => Transpose' (:. () vs) vs'

Snoc v a (:. a v) => Snoc (:. a v) a (:. a (:. a v))

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

Append (:. a ()) v (:. a v)

Length v n => Length (:. a v) (Succ n)

(Head xss_h xss_hh, Map xss_h xss_hh (:. xss_h xss_t) xs', Tail xss_h xss_ht, Map xss_h xss_ht (:. xss_h xss_t) xss_, Transpose' (:. xs xss_) xss') => Transpose' (:. (:. x xs) (:. xss_h xss_t)) (:. (:. x xs') xss')

Transpose' (:. (:. x ()) ()) (:. (:. x ()) ())

(Vec (Succ n) s (:. s ra), Vec (Succ m) (:. s ra) (:. (:. s ra) a), Vec (Succ m) s (:. s rb), Vec (Succ n) (:. s rb) (:. (:. s rb) b), Transpose' (:. (:. s ra) a) (:. (:. s rb) b)) => Transpose (:. (:. s ra) a) (:. (:. s rb) b)

class ShowVec v where

Methods

showVec :: v -> String

Instances

ShowVec ()

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

Vector Types

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

type Vec3 a = a :. Vec2 a

type Vec4 a = a :. Vec3 a

type Vec5 a = a :. Vec4 a

type Vec6 a = a :. Vec5 a

type Vec7 a = a :. Vec6 a

type Vec8 a = a :. Vec7 a

type Vec9 a = a :. Vec8 a

type Vec10 a = a :. Vec9 a

type Vec11 a = a :. Vec10 a

type Vec12 a = a :. Vec11 a

type Vec13 a = a :. Vec12 a

type Vec14 a = a :. Vec13 a

type Vec15 a = a :. Vec14 a

type Vec16 a = a :. Vec15 a

type Vec17 a = a :. Vec16 a

type Vec18 a = a :. Vec17 a

type Vec19 a = a :. Vec18 a

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

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 as.

Methods

mkVec :: n -> a -> v

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

Make a uniform vector. The length is inferred.

class VecList a v | v -> a where

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

Methods

fromList :: [a] -> v

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

Get a vector element, which one determined at runtime.

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

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

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

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

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

The first element.

Methods

head :: v -> a

Instances

(Head v h, PackedVec v) => Head (Packed v) h

Head (:. a as) a

class Tail v v_ | v -> v_ where

All but the first element.

Methods

tail :: v -> v_

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

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

Methods

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

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

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 as, v is a vector of bs, w is a vector of cs, and the binary function is of type a -> b -> c.

Methods

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

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

Fold a function over a vector.

Methods

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

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

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

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'

Reverse a vector

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

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

Methods

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

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

Append two vectors

Methods

append :: v1 -> v2 -> v3

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

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'

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

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'

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

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

Methods

last :: v -> a

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

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

Methods

snoc :: v -> a -> v'

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

The length of a vector

Methods

length :: v -> Int

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

sum of vector elements

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

product of vector elements

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

maximum vector element

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

minimum vector element

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

Matrix Types

type Mat22 a = Vec2 (Vec2 a)

type Mat23 a = Vec2 (Vec3 a)

type Mat24 a = Vec2 (Vec4 a)

type Mat32 a = Vec3 (Vec2 a)

type Mat33 a = Vec3 (Vec3 a)

type Mat34 a = Vec3 (Vec4 a)

type Mat35 a = Vec3 (Vec5 a)

type Mat36 a = Vec3 (Vec6 a)

type Mat42 a = Vec4 (Vec2 a)

type Mat43 a = Vec4 (Vec3 a)

type Mat44 a = Vec4 (Vec4 a)

type Mat45 a = Vec4 (Vec5 a)

type Mat46 a = Vec4 (Vec6 a)

type Mat47 a = Vec4 (Vec7 a)

type Mat48 a = Vec4 (Vec8 a)

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

convert a matrix to a list-of-lists

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

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

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

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

sizeOf# :: Storable a => a -> Int#

class VecArrayRW v where

Methods

vaRead# :: MutableByteArray# s# -> Int# -> State# s# -> (#State# s#, v#)

vaWrite# :: MutableByteArray# s# -> Int# -> v -> State# s# -> State# s#

vaIndex# :: ByteArray# -> Int# -> v

vaSizeOf# :: v -> Int#

vaLength# :: v -> Int#

init# :: v

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